{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a00a09c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Load required libraries\n",
    "import torch\n",
    "import tqdm\n",
    "import copy\n",
    "import numpy as np\n",
    "# -custom-written libraries\n",
    "import utils\n",
    "from data.load import get_context_set\n",
    "from models.classifier import Classifier\n",
    "from models.vae import VAE\n",
    "from eval import evaluate, callbacks as cb\n",
    "from visual import visual_plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "cb0539a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Enable plotting in the notebook\n",
    "%matplotlib inline  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "57e3b84a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CUDA is used\n"
     ]
    }
   ],
   "source": [
    "# Is cuda available?\n",
    "cuda = torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if cuda else \"cpu\")\n",
    "print(\"CUDA is {}used\".format(\"\" if cuda else \"not \"))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "320f9e43",
   "metadata": {},
   "source": [
    "## DATA: Prepare the data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c6ead555",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify what kind of continual learning experiment we should run\n",
    "experiment = \"splitMNIST\"  #--> create context set by splitting up the MNIST dataset\n",
    "contexts = 5               #--> split the dataset up into how many contexts?\n",
    "iters = 1000               #--> number of iterations per context\n",
    "batch = 128                #--> number of samples per iteration (i.e., the mini-batch size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ee01ec88",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify according to which scenario the continual learning experiment should be performed?\n",
    "scenario = \"class\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2746c66a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Where is, or should, the data be stored?\n",
    "d_dir = './store/datasets'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d9b6f329",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " --> MNIST: 'train'-dataset consisting of 60000 samples\n",
      " --> MNIST: 'test'-dataset consisting of 10000 samples\n"
     ]
    }
   ],
   "source": [
    "# Load the context set (both train- and test-data) for the specified continual learning experiment\n",
    "(train_datasets, test_datasets), config = get_context_set(\n",
    "    name=experiment, scenario=scenario, contexts=contexts, data_dir=d_dir, verbose=True, exception=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51fc95ea",
   "metadata": {},
   "source": [
    "## CLASSIFIER: Specify the classifier network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "06a212fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the architectural layout of the network to use\n",
    "fc_lay = 3        #--> number of fully-connected layers\n",
    "fc_units = 400    #--> number of units in each hidden layer\n",
    "fc_bn = False     #--> use batch-norm\n",
    "fc_nl = \"relu\"    #--> what non-linearity to use?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "a9749091",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the model\n",
    "model = Classifier(\n",
    "    image_size=config['size'], image_channels=config['channels'], classes=config['output_units'],\n",
    "    # -conv-layers are not used\n",
    "    depth=0,\n",
    "    # -fc-layers\n",
    "    fc_layers=fc_lay, fc_units=fc_units, fc_bn=fc_bn, fc_nl=fc_nl, excit_buffer=True,\n",
    ").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d6b15c63",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indicate to model what scenario it will be trained on and how many classes there are in each context\n",
    "model.scenario = scenario\n",
    "model.classes_per_context = config['classes_per_context']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6b08f0cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indicate to the classifier model that it will be trained with generative replay\n",
    "model.replay_mode = 'generative'\n",
    "model.replay_targets = 'hard'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "749dc0cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------\n",
      "Classifier(\n",
      "  (convE): ConvLayers(\n",
      "    (pooling): Identity()\n",
      "  )\n",
      "  (flatten): Flatten()\n",
      "  (fcE): MLP(\n",
      "    (fcLayer1): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=784, out_features=400)\n",
      "      (nl): ReLU()\n",
      "    )\n",
      "    (fcLayer2): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=400)\n",
      "      (nl): ReLU()\n",
      "    )\n",
      "  )\n",
      "  (classifier): fc_layer(\n",
      "    (linear): LinearExcitability(in_features=400, out_features=10)\n",
      "  )\n",
      ")\n",
      "-------------------------------------------------------\n",
      "--> this network has 478410 parameters (~0.5 million)\n",
      "       of which: - learnable: 478410 (~0.5 million)\n",
      "                 - fixed: 0 (~0.0 million)\n"
     ]
    }
   ],
   "source": [
    "# Print layout of the model to the screen\n",
    "utils.print_model_info(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10f44613",
   "metadata": {},
   "source": [
    "## GENERATOR: Specify the generative model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "67d36f29",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Specify the architectural layout of the network to use\n",
    "g_fc_lay = 3        #--> number of fully-connected layers\n",
    "g_fc_units = 400    #--> number of units in each hidden layer\n",
    "g_fc_bn = False     #--> use batch-norm\n",
    "g_fc_nl = \"relu\"    #--> what non-linearity to use?\n",
    "g_z_dim = 100       #--> number of units in latent space VAE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "654bd91d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the model\n",
    "generator = VAE(\n",
    "    image_size=config['size'], image_channels=config['channels'],\n",
    "    # -conv-layers are not used\n",
    "    depth=0,\n",
    "    # -fc-layers\n",
    "    fc_layers=g_fc_lay, fc_units=g_fc_units, fc_bn=g_fc_bn, fc_nl=g_fc_nl, excit_buffer=True,\n",
    "    # -prior\n",
    "    prior='standard', z_dim=g_z_dim,\n",
    "    #-decoder\n",
    "    recon_loss='BCE', network_output='sigmoid'\n",
    ").to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3a2575d3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-------------------------------------------------------\n",
      "VAE(\n",
      "  (convE): ConvLayers(\n",
      "    (pooling): Identity()\n",
      "  )\n",
      "  (flatten): Flatten()\n",
      "  (fcE): MLP(\n",
      "    (fcLayer1): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=784, out_features=400)\n",
      "      (nl): ReLU()\n",
      "    )\n",
      "    (fcLayer2): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=400)\n",
      "      (nl): ReLU()\n",
      "    )\n",
      "  )\n",
      "  (toZ): fc_layer_split(\n",
      "    (mean): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=100)\n",
      "    )\n",
      "    (logvar): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=100)\n",
      "    )\n",
      "  )\n",
      "  (fromZ): fc_layer(\n",
      "    (linear): LinearExcitability(in_features=100, out_features=400)\n",
      "    (nl): ReLU()\n",
      "  )\n",
      "  (fcD): MLP(\n",
      "    (fcLayer1): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=400)\n",
      "      (nl): ReLU()\n",
      "    )\n",
      "    (fcLayer2): fc_layer(\n",
      "      (linear): LinearExcitability(in_features=400, out_features=784)\n",
      "      (nl): Sigmoid()\n",
      "    )\n",
      "  )\n",
      "  (to_image): Reshape(channels = 1)\n",
      "  (convD): DeconvLayers()\n",
      ")\n",
      "-------------------------------------------------------\n",
      "--> this network has 1069684 parameters (~1.1 million)\n",
      "       of which: - learnable: 1069684 (~1.1 million)\n",
      "                 - fixed: 0 (~0.0 million)\n"
     ]
    }
   ],
   "source": [
    "# Print layout of the generator to the screen\n",
    "utils.print_model_info(generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6448262e",
   "metadata": {},
   "source": [
    "## PREPARE FOR TRAINING"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "680da4f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Settings for the optimizer to use\n",
    "lr = 0.001           #--> learning rate to use"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8e3602ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the classifier model, set up the optimizer to use\n",
    "model.optim_list = [{'params': filter(lambda p: p.requires_grad, model.parameters()), 'lr': lr}]\n",
    "model.optimizer = torch.optim.Adam(model.optim_list, betas=(0.9, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fe5483d1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# For the generative model, set up the optimizer to use\n",
    "generator.optim_list = [{'params': filter(lambda p: p.requires_grad, generator.parameters()), 'lr': lr}]\n",
    "generator.optimizer = torch.optim.Adam(generator.optim_list, betas=(0.9, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c0403c75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Prepare for keeping track of performance (on test set) during training, for later plotting\n",
    "plotting_dict = evaluate.initiate_plotting_dict(contexts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "fe52ca66",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define callback function for keeping track of performance trhoughout training\n",
    "eval_periodicity = 50\n",
    "eval_cb = cb._eval_cb(log=eval_periodicity, test_datasets=test_datasets, plotting_dict=plotting_dict,\n",
    "                      visdom=None, iters_per_context=iters, test_size=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "1e4e4e84",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set the models in training mode\n",
    "_ = model.train()\n",
    "_ = generator.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81b4b344",
   "metadata": {},
   "source": [
    "## TRAIN: Train the classifier and generative model on the continual learning experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "c6013758",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<CLASSIFIER> | Context: 1/5 | training loss: 1.02e-06 | training accuracy: 1.0 |: 100%|████████████████████████████| 1000/1000 [00:28<00:00, 35.00it/s]\n",
      "<CLASSIFIER> | Context: 2/5 | training loss: 0.00302 | training accuracy: 1.0 |: 100%|█████████████████████████████| 1000/1000 [00:35<00:00, 27.94it/s]\n",
      "<CLASSIFIER> | Context: 3/5 | training loss: 0.0424 | training accuracy: 1.0 |: 100%|██████████████████████████████| 1000/1000 [00:36<00:00, 27.69it/s]\n",
      "<CLASSIFIER> | Context: 4/5 | training loss: 0.0366 | training accuracy: 1.0 |: 100%|██████████████████████████████| 1000/1000 [00:36<00:00, 27.38it/s]\n",
      "<CLASSIFIER> | Context: 5/5 | training loss: 0.14 | training accuracy: 0.977 |: 100%|██████████████████████████████| 1000/1000 [00:37<00:00, 26.70it/s]\n"
     ]
    }
   ],
   "source": [
    "# Indicate that on first context, there are no stored models yet for generating replay\n",
    "previous_model = previous_generator = None\n",
    "    \n",
    "# Loop over all contexts.\n",
    "for context, train_dataset in enumerate(train_datasets, 1):\n",
    "    \n",
    "    # Find [active_classes]\n",
    "    if scenario==\"task\":\n",
    "        # -for Task-IL scenario, create <list> with for all contexts so far a <list> with the active classes\n",
    "        active_classes = [list(\n",
    "            range(model.classes_per_context * i, model.classes_per_context * (i+1))\n",
    "        ) for i in range(context)]\n",
    "    else:\n",
    "        # -for Domain- and Class-IL scenario, always all classes are active\n",
    "        active_classes = None\n",
    "    \n",
    "    # Initialize # iters left on current data-loader(s)\n",
    "    iters_left = 1\n",
    "    \n",
    "    # Define tqdm progress bar\n",
    "    progress = tqdm.tqdm(range(1, iters+1))\n",
    "    \n",
    "    # Loop over all iterations\n",
    "    for batch_index in range(1, iters+1):\n",
    "        \n",
    "        # Update # iters left on current data-loader(s) and, if needed, create new one(s)\n",
    "        iters_left -= 1\n",
    "        if iters_left==0:\n",
    "            data_loader = iter(utils.get_data_loader(train_dataset, batch, cuda=cuda, drop_last=True))\n",
    "            iters_left = len(data_loader)\n",
    "            \n",
    "        # -----------------Collect data------------------#\n",
    "\n",
    "        #--> Sample training data of current context\n",
    "        x, y = next(data_loader)\n",
    "        # Adjust y-targets to 'active range'\n",
    "        y = y-model.classes_per_context*(context-1) if scenario=='task' else y\n",
    "        # Transfer them to correct device\n",
    "        x, y = x.to(device), y.to(device)\n",
    "        \n",
    "        #--> Sample inputs to be replayed from stored copy of generative model\n",
    "        if previous_model is not None:\n",
    "            x_ = previous_generator.sample(batch, only_x=True)\n",
    "            if not scenario=='task':\n",
    "                with torch.no_grad():\n",
    "                    scores_ = previous_model.classify(x_)\n",
    "                _, y_ = torch.max(scores_, dim=1)\n",
    "            else:\n",
    "                # With Task-IL, [x_] needs to be evaluated according to each past context\n",
    "                scores_ = list()\n",
    "                y_ = list()\n",
    "                with torch.no_grad():\n",
    "                    all_scores_ = previous_model.classify(x_)\n",
    "                for context_id in range(context-1):\n",
    "                    temp_scores_ = all_scores_[:, active_classes[context_id]]\n",
    "                    scores_.append(temp_scores_)\n",
    "                    _, temp_y_ = torch.max(temp_scores_, dim=1)\n",
    "                    y_.append(temp_y_)\n",
    "\n",
    "            # Only keep predicted y/scores if required (as otherwise unnecessary computations will be done)\n",
    "            y_ = y_ if (model.replay_targets == \"hard\") else None\n",
    "            scores_ = scores_ if (model.replay_targets == \"soft\") else None\n",
    "        else:\n",
    "            x_ = y_ = scores_ = None    #-> when training on the first context, there is no replay yet\n",
    "        \n",
    "        # Train the classifier model on this batch\n",
    "        loss_dict = model.train_a_batch(\n",
    "            x, y, x_=x_, y_=y_, scores_=scores_, rnt = 1./context,\n",
    "            active_classes=active_classes, context=context\n",
    "        )\n",
    "            \n",
    "        # Train the generative model on this batch\n",
    "        _ = generator.train_a_batch(x, x_=x_, rnt=1./context)\n",
    "        \n",
    "        # Update progress bar\n",
    "        context_stm = \" Context: {}/{} |\".format(context, contexts)\n",
    "        progress.set_description(\n",
    "            '<CLASSIFIER> |{t_stm} training loss: {loss:.3} | training accuracy: {prec:.3} |'\n",
    "                .format(t_stm=context_stm, loss=loss_dict['loss_total'], prec=loss_dict['accuracy'])\n",
    "        )\n",
    "        progress.update(1)\n",
    "        \n",
    "        # Execute callback-function to keep track of performance throughout training\n",
    "        if eval_cb is not None:\n",
    "            eval_cb(model, batch_index, context=context)\n",
    "    \n",
    "    ##----------> UPON FINISHING EACH CONTEXT...\n",
    "\n",
    "    # Close progres-bar\n",
    "    progress.close()\n",
    "    \n",
    "    # Update the source for the replay\n",
    "    previous_generator = copy.deepcopy(generator).eval()\n",
    "    previous_model = copy.deepcopy(model).eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41bcf17f",
   "metadata": {},
   "source": [
    "## EVALUATION: average accuracy throughout training and samples from generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "ca4edf2d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAakAAAGzCAYAAACVYeimAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9d5gdV30+/t7e6/aVVqtqybJNDMYY00wxCGJTAgQIKTYQ4AfGYEwJ9hOw5RIDSbCDCwGSAAEcCAESEgIkOJQETPnagA2y1etq+97ey/z+EO/RZ87OXRXv7p2V5n2e+9zduW3mzDmf8n7KcRmGYcCBAwcOHDiwIdzdPgEHDhw4cOCgExwl5cCBAwcObAtHSTlw4MCBA9vCUVIOHDhw4MC2cJSUAwcOHDiwLRwl5cCBAwcObAtHSTlw4MCBA9vCUVIOHDhw4MC2cJSUAwcOHDiwLRwl5WBR4HK5cPPNNy/rb05OTuLVr341enp64HK5cNdddy3r7zs4NRw4cAAulwuf/exnu30qy461a9fi6quvPq3PdmNt2QmOkrIRHn30Ubz61a/G6OgogsEgVq1ahRe+8IW4++67u31qtsS73/1ufOc738ENN9yAz3/+83jxi1/c7VNyAOD+++93DAYHiwZvt0/AwTH8+Mc/xvOe9zysWbMGb37zmzE4OIjDhw/jJz/5Cf7mb/4G1157bbdP0Xb4n//5H7z85S/He9/73m6figOB+++/H7/+9a9x3XXXmY6Pjo6iUqnA5/N158QcrEg4SsomuP3225FIJPDzn/8cyWTS9NrU1FR3TsrmmJqamjdWViiVSohEIkt/QmcoyuUywuHwE/4el8uFYDC4CGfk4GyCQ/fZBHv37sV5551nKXT7+/tN/3/mM5/B85//fPT39yMQCGDr1q34xCc+Me9za9euxZVXXonvf//7eOpTn4pQKIQLLrgA3//+9wEAX/va13DBBRcgGAzioosuwi9+8QvT56+++mpEo1Hs27cP27ZtQyQSwfDwMG655RacTPP8sbExvPGNb8TAwAACgQDOO+88/MM//MO89919990477zzEA6HkUql8NSnPhX3339/x+/97Gc/C5fLBcMwcO+998LlcsHlcple+8EPfoC3v/3t6O/vx+rVq9Vn77vvPpx33nkIBAIYHh7GNddcg2w2a/r+5z73uTj//PPxyCOP4LLLLkM4HMbGjRvxL//yLwCAH/zgB7jkkksQCoWwefNmfPe73z3hWADAwYMH8bKXvQyRSAT9/f2KrnS5XOqeED/96U/x4he/GIlEAuFwGJdddhl+9KMfmd5z8803w+VyYc+ePbj66quRTCaRSCTwhje8AeVyed7vf+ELX8BFF12EUCiEdDqN173udTh8+LDltT/00EN4znOeg3A4jBtvvBEA8G//9m+44oorMDw8jEAggA0bNuDWW29Fq9Uyff6b3/wmDh48qO7L2rVrAcyPSf3VX/0VXC4XDh48OO9cb7jhBvj9fmQymVMaEyt8//vfh8vlwj//8z9j+/btWLVqFWKxGF796lcjl8uhVqvhuuuuQ39/P6LRKN7whjegVquZvqPZbOLWW2/Fhg0bEAgEsHbtWtx4443z3mcYBm677TasXr0a4XAYz3ve8/Cb3/zG8ryy2Syuu+46jIyMIBAIYOPGjfjIRz6Cdrt9wms6q2A4sAVe9KIXGbFYzHj00UdP+N6LL77YuPrqq40777zTuPvuu40XvehFBgDjnnvuMb1vdHTU2Lx5szE0NGTcfPPNxp133mmsWrXKiEajxhe+8AVjzZo1xoc//GHjwx/+sJFIJIyNGzcarVZLff6qq64ygsGgsWnTJuOP//iPjXvuuce48sorDQDGBz/4QdNvATBuuukm9f/ExISxevVqY2RkxLjllluMT3ziE8bLXvYyA4Bx5513qvd96lOfMgAYr371q41PfvKTxt/8zd8Yb3rTm4x3vvOdHa9/7969xuc//3kDgPHCF77Q+PznP298/vOfNwzDMD7zmc8YAIytW7cal112mXH33XcbH/7whw3DMIybbrrJAGBcfvnlxt1332284x3vMDwej3HxxRcb9Xpdff9ll11mDA8PGyMjI8b73vc+4+677za2bt1qeDwe40tf+pIxODho3HzzzcZdd91lrFq1ykgkEkY+n1/wnhWLRWP9+vVGKBQyPvCBDxh33XWX8bSnPc34nd/5HQOA8b3vfU+994EHHjD8fr9x6aWXGn/9139t3HnnncaTnvQkw+/3Gz/96U/V+3g9T37yk41XvvKVxn333Wf86Z/+qQHAeP/732/6/dtuu81wuVzGa1/7WuO+++4ztm/fbvT29hpr1641MpmM6doHBweNvr4+49prrzU++clPGv/6r/9qGIZhvOIVrzBe85rXGH/5l39pfOITnzB+//d/3wBgvPe971Wf/6//+i/jwgsvNHp7e9V9+frXv24YhmHs37/fAGB85jOfMQzDMA4ePGi4XC7jox/96LzxWr9+vXHFFVec8phY4Xvf+54BwLjwwguNSy+91Pj4xz9uvPOd7zRcLpfxute9znj9619vvOQlLzHuvfde44//+I8NAMb27dtN33HVVVepeXrvvfcaf/Inf2IAMF7xileY3vfnf/7nBgDjd3/3d4177rnHeOMb32gMDw8bvb29xlVXXaXeVyqVjCc96UlGT0+PceONNxp/+7d/a/zJn/yJ4XK5jHe9612m79TX1tkGR0nZBP/1X/9leDwew+PxGJdeeqnx/ve/3/jOd75jEp5EuVyed2zbtm3G+vXrTcdGR0cNAMaPf/xjdew73/mOAcAIhULGwYMH1fFPfvKT84QlF+a1116rjrXbbeOKK64w/H6/MT09rY7rC+lNb3qTMTQ0ZMzMzJjO6XWve52RSCTUNbz85S83zjvvvBOMjjUAGNdcc43pGJXUs571LKPZbKrjU1NTht/vN170oheZFPE999xjADD+4R/+QR277LLLDADG/fffr449/vjjBgDD7XYbP/nJT9RxjicFbyf89V//tQFACXzDMIxKpWJs2bLFNO7tdtvYtGmTsW3bNqPdbqv3lstlY926dcYLX/hCdYxK6o1vfKPpt37v937P6OnpUf8fOHDA8Hg8xu23325636OPPmp4vV7TcV773/7t3867Bqt599a3vtUIh8NGtVpVx6644gpjdHR03nt1JWUYhnHppZcaF110kel9P/vZzwwAxj/+4z+e8phYgUrq/PPPN62nP/iDPzBcLpfxkpe8xPT+Sy+91HT+v/zlLw0Axp/+6Z+a3vfe977XAGD8z//8j2EYx+fYFVdcYTrPG2+80QBgUlK33nqrEYlEjF27dpm+8wMf+IDh8XiMQ4cOqWNnu5Jy6D6b4IUvfCEefPBBvOxlL8OvfvUrfPSjH8W2bduwatUqfOMb3zC9NxQKqb9zuRxmZmZw2WWXYd++fcjlcqb3bt26FZdeeqn6/5JLLgEAPP/5z8eaNWvmHd+3b9+8c3vHO96h/na5XHjHO96Ber3ekeYyDANf/epX8dKXvhSGYWBmZkY9tm3bhlwuh4cffhgAkEwmceTIEfz85z8/qXE6Wbz5zW+Gx+NR/3/3u99FvV7HddddB7fbbXpfPB7HN7/5TdPno9EoXve616n/N2/ejGQyiXPPPVeNFbDwuEl8+9vfxqpVq/Cyl71MHQsGg3jzm99set8vf/lL7N69G69//esxOzurxq1UKuEFL3gBfvjDH86jg/6//+//M/3/7Gc/G7Ozs8jn8wCO0brtdhuvec1rTPdicHAQmzZtwve+9z3T5wOBAN7whjfMuwY57wqFAmZmZvDsZz8b5XIZjz/++ILX3wmvfe1r8dBDD2Hv3r3q2Je//GUEAgG8/OUvP+0xscKf/MmfmJI2LrnkEhiGgTe+8Y2m911yySU4fPgwms0mAOA///M/AQDXX3+96X3vec97AEDNHc6xa6+9VtHPAOYlkADAV77yFTz72c9GKpUy3ZPLL78crVYLP/zhD094PWcLnMQJG+Hiiy/G1772NdTrdfzqV7/C17/+ddx555149atfjV/+8pfYunUrAOBHP/oRbrrpJjz44IPzYg+5XA6JREL9LxURAPXayMiI5XEZAwAAt9uN9evXm46dc845AI7FGKwwPT2NbDaLT33qU/jUpz5l+R4mg/zZn/0Zvvvd7+JpT3saNm7ciBe96EV4/etfj2c+85mWnztZrFu3zvQ/4x6bN282Hff7/Vi/fv28uMjq1atNggY4NkYnO246Dh48iA0bNsz7zo0bN5r+3717NwDgqquu6vhduVwOqVRK/a/fY76WyWQQj8exe/duGIaBTZs2WX6fnm23atUq+P3+ee/7zW9+gz//8z/H//zP/ygFKM/pdPD7v//7uP766/HlL38ZN954IwzDwFe+8hW85CUvQTweB3B6Y2KFU1kL7XYbuVwOPT09OHjwINxu97x7NTg4iGQyqeYOn/Vx7uvrm3duu3fvxiOPPIK+vj7Lc3WSpY7DUVI2hN/vx8UXX4yLL74Y55xzDt7whjfgK1/5Cm666Sbs3bsXL3jBC7BlyxZ87GMfw8jICPx+P/7zP/8Td9555zyLUnoTJ3PcOImEiBOB5/BHf/RHHQXLk570JADAueeei507d+I//uM/8O1vfxtf/epXcd999+FDH/oQtm/fftrnIK3+00E3xg04PnZ/+Zd/iQsvvNDyPdFo9JTOqd1uw+Vy4Vvf+pble/Xvsxq7bDaLyy67DPF4HLfccgs2bNiAYDCIhx9+GH/2Z3922sH+4eFhPPvZz8Y///M/48Ybb8RPfvITHDp0CB/5yEfUe05nTKzwRO+pbmA8EbTbbbzwhS/E+9//fsvXaQg6cJSU7fHUpz4VADA+Pg4A+Pd//3fUajV84xvfMFmGOmWzWGi329i3b59p0ezatQsAVNaWjr6+PsRiMbRaLVx++eUn/I1IJILXvva1eO1rX4t6vY5XvvKVuP3223HDDTcsWsry6OgoAGDnzp0mz7Ber2P//v0ndZ5P9Pd37NgBwzBMwm7Pnj2m923YsAEAEI/HF+2cNmzYAMMwsG7dutMWft///vcxOzuLr33ta3jOc56jju/fv3/ee09VmL/2ta/F29/+duzcuRNf/vKXEQ6H8dKXvtR0/sDijsmpYHR0FO12G7t378a5556rjk9OTiKbzaq5xefdu3eb5tj09PQ8T3vDhg0oFotduZ6VBicmZRN873vfs7TGyYeTpqLVJ9+by+Xwmc98ZsnO7Z577lF/G4aBe+65Bz6fDy94wQss3+/xePCqV70KX/3qV/HrX/963uvT09Pq79nZWdNrfr8fW7duhWEYaDQai3QFwOWXXw6/34+Pf/zjprH7+7//e+RyOVxxxRWL9ltW2LZtG8bGxkzxxWq1ik9/+tOm91100UXYsGED/uqv/grFYnHe98ixO1m88pWvhMfjwfbt2+fNMcMw5t0DK1jNu3q9jvvuu2/eeyORyCnRf6961avg8XjwT//0T/jKV76CK6+80lTXthRjcir43d/9XQCY10XjYx/7GACouXP55ZfD5/Ph7rvvNo2TVfeN17zmNXjwwQfxne98Z95r2WxWxcMcOJ6UbXDttdeiXC7j937v97BlyxbU63X8+Mc/xpe//GWsXbtWBbJf9KIXwe/346UvfSne+ta3olgs4tOf/jT6+/uVt7WYCAaD+Pa3v42rrroKl1xyCb71rW/hm9/8Jm688caOfDoAfPjDH8b3vvc9XHLJJXjzm9+MrVu3Ym5uDg8//DC++93vYm5uTl3P4OAgnvnMZ2JgYACPPfYY7rnnHlxxxRWIxWKLdh19fX244YYbsH37drz4xS/Gy172MuzcuRP33XcfLr74YvzRH/3Rov2WFd761rfinnvuwR/8wR/gXe96F4aGhvDFL35ReYr0PtxuN/7u7/4OL3nJS3DeeefhDW94A1atWoWxsTF873vfQzwex7//+7+f0m9v2LABt912G2644QYcOHAAr3jFKxCLxbB//358/etfx1ve8pYTdu14xjOegVQqhauuugrvfOc74XK58PnPf97SsLrooovw5S9/Gddffz0uvvhiRKNRk2eko7+/H8973vPwsY99DIVCAa997WtNry/FmJwKfud3fgdXXXUVPvWpTyna82c/+xk+97nP4RWveAWe97znATg2x9773vfijjvuwJVXXonf/d3fxS9+8Qt861vfQm9vr+k73/e+9+Eb3/gGrrzySlx99dW46KKLUCqV8Oijj+Jf/uVfcODAgXmfOWuxrLmEDjriW9/6lvHGN77R2LJlixGNRg2/329s3LjRuPbaa43JyUnTe7/xjW8YT3rSk4xgMGisXbvW+MhHPmL8wz/8gwHA2L9/v3rf6OioqdaEgEXqNtOD//Iv/1Idu+qqq4xIJGLs3bvXeNGLXmSEw2FjYGDAuOmmm0xp3PxOPU12cnLSuOaaa4yRkRHD5/MZg4ODxgte8ALjU5/6lHrPJz/5SeM5z3mO0dPTYwQCAWPDhg3G+973PiOXy51wzKyugynoP//5zy0/c8899xhbtmwxfD6fMTAwYLztbW8z1QkZxrE0bKu0+FMZTyvs27fPuOKKK4xQKGT09fUZ73nPe4yvfvWrBgBTWrthGMYvfvEL45WvfKUal9HRUeM1r3mN8cADD6j3MAVdlgLIMZBzwTAM46tf/arxrGc9y4hEIkYkEjG2bNliXHPNNcbOnTtPeO2GYRg/+tGPjKc//elGKBQyhoeHVZkEtNKFYrFovP71rzeSyaQBQKVzW6WgE5/+9KcNAEYsFjMqlYrl75/MmFiBKehf+cpXLMdJnytW49poNIzt27cb69atM3w+nzEyMmLccMMNptR7wzCMVqtlbN++3RgaGjJCoZDx3Oc+1/j1r39tjI6OmlLQDcMwCoWCccMNNxgbN240/H6/0dvbazzjGc8w/uqv/sqUKm+1ts4muAxjkSK+Ds44XH311fiXf/kXS4rFweLgrrvuwrvf/W4cOXIEq1at6vbpOHBgOzgxKQcOlgmVSsX0f7VaxSc/+Uls2rTJUVAOHHSAE5Ny4GCZ8MpXvhJr1qzBhRdeiFwuhy984Qt4/PHH8cUvfrHbp+bAgW3hKCkHDpYJ27Ztw9/93d/hi1/8IlqtFrZu3YovfelL8xIFHDhwcBxOTMqBAwcOHNgWXYtJ3XvvvVi7di2CwSAuueQS/OxnP+vWqThw4MCBA5uiK0qKNRQ33XQTHn74YfzO7/wOtm3b5vSrcuDAgQMHJnSF7rvkkktw8cUXq04G7XYbIyMjuPbaa/GBD3zghJ9vt9s4evQoYrHYovbTcuDAgQMHywPDMFAoFDA8PGzamUDHsidO1Ot1PPTQQ7jhhhvUMbfbjcsvvxwPPvig5WdqtZppB8yxsTHVEdyBAwcOHKxcHD582LR7to5lV1IzMzNotVoYGBgwHR8YGOi4J80dd9xh2RH78OHDqp2/AwcOHDhYOcjn8xgZGTlh+7MVkYJ+ww03mDYc48XF43FHSTlw4MDBCsaJQjbLrqR6e3vh8XgwOTlpOj45OYnBwUHLzwQCAQQCgQW/d2ZmBjt27JhX1X+2Ih6PY+vWraYNEGdnZ7Fjx455GyWerYjFYti6dSuSyaQ6Njc3hx07dqBUKnXvxGyEaDSKrVu3mjbty2Qy2LFjh9Mu67eIRCLYunUr0um0OpbNZrFjxw4UCoUunpl9EA6HsXXrVvT09JzyZ5ddSfn9flx00UV44IEH8IpXvALAsUSIBx54wLRN+anisccewwc/+EEcOXJkkc50ZWPr1q24/fbb1eaCAPD444/jpptumrcL7dmKzZs347bbbsNTnvIUdWz37t3Yvn37CbeDP1uwceNG3Hbbbbj44ovVsb179+LWW29VO+ae7Vi3bh1uv/12XHLJJerYgQMHcPvtt3cMYZxtGB0dxa233npaO253he67/vrrcdVVV+GpT30qnva0p+Guu+5CqVRS21GcDsrlMg4fPmy5CdvZiEQiYUo2AY71jjt8+LAjgH+LSCTijNEJEAgEUK1WTceq1SqOHDnijNFv4fV6LfsyOmN0HG63+7RZrq4oqde+9rWYnp7Ghz70IUxMTODCCy/Et7/97XnJFA4cOHDg4OxG1xIn3vGOdzwhes+BAwcOHJz5WBHZfQ4cOHDg4HgmnMvlgtvttsyMc7lcMAzD9AAw73mlwFFSDhw4cGBzSOXEh9/vh9frNSkidm5ot9tot9swDAOtVku9p91uA1hZispRUg4cOHBgY+jek9frhdvtRigUgt/vh8vlgsfjAQCljJrNJhqNBtrtNur1OtrtNlqtlvouR0k5cHCSkHTFSlo4DhwsNaiUgGMektvtRjAYRDqdRiAQQG9vL2KxGKLRKHp7ewEAuVwO1WoVhUIBmUwGtVoNMzMzqFarqNfrKpuVlOBKgKOkHCwrFuLQV6KV58DBUkB6T8BxJeXz+RCNRhEKhdDb24tUKoVUKqV6301NTaFUKmFubg7AsdKcQqGAVqtl8qRWEhwl5WBJoS828ukSVFBWyslRWAujk9CRx/Wx7fT3ckM/R/lslRQgA/+dkgLOBMikCFJ7wWAQwWAQ8Xgcg4ODCIfDGB0dRV9fH4LBIKLRKFqtFkKhEFqtFoLBIPx+P5rNJvx+PxqNBur1+oryoAhHSTlYElgFeuXDKsArwf/PZu/qZKzeToJeF/pSoOv/d2Ns9XPUlROFszw/PjO+wkSAM0lRcW1Iz8nj8SAejyORSCCZTGL16tWIRqPYtGkTVq1ahVarhUajgUajgUgkAsMwUKlUEAwG0W63lZKq1WqWRqLd4SgpB4sKK+VEwePxeODxeDoqKT7Lh8xGOpOEEdHJ05Rj1EmgdzIA5PfJsdXHudVqLXu2l1UKNZ85R5i55vF4LO+7TArgNRJnytyQ4+H1euHz+dSz3++H3++HYRio1WpoNBool8toNBrI5/MolUooFosolUqoVCqo1+toNptotVqm7wdWxng5SsrBKaNTXEk+MwuJAofZSKFQyFJJtdttNBoNGIaBRqOBVqulhJEUqFZUz0pCJwVD4UxB5Ha71bhRucvMLqn4+X7pfQBAq9VCpVJBs9lEvV5HvV5Hq9VCrVZDq9VSwXRmgwFLJ7R05eR2uxEIBNS18cFjzFyjlwBAZbAVi0Xk83nTtXAOLeU1LDX0NeTxeBAOh+H3+xEOhxEKhRAOh5FIJBAOh00KaWZmBvV6HTMzMyiXy8jn85ibm0Oj0UCxWESj0UCz2ZzHUAD2Hy9HSS0h9IWpHyOsiu1WkuegKy2dsvB6vUoAhUIhk+VM2qbVasHj8aDdbsPlcqHZbCr+nAJIWn8rkVu38pqksqFiohcRDAZNlI/H4zGlHHNsqcx0iqzVasHn86HRaKBarcLr9SpBReHvdrvV2C71eMp5QeVKT4GPYDAIj8eDSCSCQCCgDBXgOBXYbDZRqVTgcrlUnMWK3lzpkEYL1xDHyePxoFarodlsIp/PY3Z2FrVaDXNzc6hUKigUCsjn88pAkV4zvxtYGePkKKlFgrSKKSwSiQQikQiSySRGRkYQDAaRTCaVoPZ4PMrabTQaKBQKKBQKKJVKOHLkCMrlsnLbJfXVzWvU/5eeEwCT8AwEAvB6vYhEIvD7/YjFYmrrEF5Ls9lEu91Wi4l1Ha1WC/V6HZVKxTRGsjBxpSw0PW4k4y4syKTFHIvFkEwm4ff7kUgk4PP5EIlE1Jyh18TvoeICjnulFOycU41GQ1E/1WoVc3NzyoNi1pekgp7oeFpRkjxnJgD4fD7EYjH1HA6H1ZzhNbFQlR4050U4HEYwGESlUsH09DSq1apSvnJu2H1edIIeO5RxNzZA9nq9qFar6t5mMhl1v2u1GqrVKqrVqil+J+8L7/dKGCdHSS0SpJXo9/vh8/nQ19eHvr4+rFmzBk9/+tORSCQwMjKCVCqlLKJms6msn4mJCYyPj2NmZgY/+9nPVBopJ5tdKK6F4k608vx+P0KhEHw+HxKJhFLQ6XRaUXoUqOTLeZ1URrVaDR6Px6ScgPkxCLsutE5JDRwrn8+nsrBSqRRCoRD6+vowODio/g4Gg0ilUojFYsqS1g0in88HwzBQLpfRbDZRrVZNMYp6vY5CoaAMHpfLhUqloh48r8Uaw07xSLfbjUgkgng8jkAggGQyqep9UqmUmjdUvvI72u22EsCkAkn7kRKmQLfrfDhV6NQ2EyKOHj0KwzBQKpVQq9VQq9VQLBZN9K5ueADH09j177T7eDlK6jTBBURqhpk3gUAAqVQKgUAAAwMDSKfT6O/vx6pVqxCNRpXAobfBCcVMHJfLhVAohNnZWaRSKZPwqVQqlplwdoKMsfh8PgQCAVXXEY1GEQ6HVQyk3W6jXC6brDoZn2FmEoUxKQsr2s9uC62TguL1kf6MRqMIBALo6elBJBJBX18fent7lRD3+/3zPCn5nZxHhmEozxU4psg9Ho/aZoPevX5eVvHFJ3rdVEhWiRDhcBixWExdO+cIjbZAIGCKq0nBGgqF4PV6lXEDAKFQCM1mE7VazTKRYiVBsgPAccOB18vsPI5HpVJBrVZDvV5XhpyM3RLSKOL4kbVYCWPlKKnTACeKz+dTFvCFF16IJz/5yUin09i6dSui0agSzj6fD6FQyBTk5vcYhoFEIoFWq4Xh4WFUq1WUSiWsXbsWuVwO//3f/41KpYJSqaSCn3ZVVLo3GYlEEA6HMTw8jHg8jkgkgkgkAuA4zTc1NYVarWaisDg+9BJIXQFQCs4qjmcHRWVFiQLHhS0TBvx+P5LJJAYGBhCNRrFhwwakUimk02n09fXB5/MhHA4r70IqaypwXcCQ9qtWq/D7/SpmUa1WUalUlPKQ1DEpZyqsJzJ+/A6fz2eKN1E5kV0YGBhQ1+f1ehEKhRQFGI1GVayp2WyqOeByudTcicfjiMViyOVyyOVy8Pv9yOfz8xJs7LpOTgSdlnO73SiVSqjX6wBg8qqYOCITjHjNUjm53W6Ew2GEw2FFC3IN8v7bdawcJXWK4E2XgiYSiWBwcBCrV69Gb28v1q1bh1gshmAwqLa9161WKVwpOGhJ+nw+9Pf3K4osHA6ryboSIJU4aT/GETgeFI608NvttulZHy+Z4bbY1v9SwSpRQnpSzNoiBZZIJBCPxxGNRpWnJbMkpQLn90kKWB83fb7JTMqlFOCSpuO1yvRpznF6V7Iswcq7kwk4brdbZX7W63UEAgHliXEd2VngniwkW6ArEh6TqeUyVis9MnkfKLc4B8lK2H28HCV1kiBl4fV6sXnzZjzlKU9BPB7Hhg0bkEgkMDQ0pGIJqVRKLUDCKnXaKsbC3yF1uGbNGmzevBkTExOYnZ01Tcblhk5HSOiCKRKJoL+/H7FYDENDQyoJwOfzodlsqlYt9LiYiUalTWEkEygohEjt2Lk+xkox0bugwu7p6cGaNWsQi8WwevVqRe+xPkgmzFB501uiV00FAByfY8zsqtfryGazqn/b7OwsKpWK6ukmLfEnqrSkkpHnLIWmy+VSsUcaXVTAvKZyuWy6FjIS9LiksvN4PMrrZCyT1BexEr0pqYhIa8pYEu8XlbWVbOH90JNy4vG4SrhgjRU9NLvCUVInCXpQfr8fo6OjeM5znoPe3l6cf/75SKfTilPne4mFMnXks7SGvV6v4uv7+/uxevVqNJtNU2aXXSEbYSaTScRiMaRSKSSTSbVwarWaCuAz7ZhCyzAM5TFxIZIupYDT6VL9bzvAKrtNxl2CwSBisRj6+voQj8fR09ODRCJhspxJ17HGid4VACVgpHVM+iaXyyGTyaBer6vEgtnZWZWmTOqI3y8posWg+wCYFJR8jUaHYRgqvsb7zWsmqyBrqTgHpPdFqtwwDBSLRRQKBTV/JKVpt7lxMpCKSi+6tvKIdcNVGoz0Num1u91uFItFNVZ2h6OkTgBmYIVCIZx33nkYGBjABRdcgJGREcTjcRVr0l3xdrutqr1rtZoqPmSAMxgMIhKJqBRtKiB90jDATP7e4/Eo68oukAuCdE4kElGWGwP/fC+TQ+S1yFRZKbQYMA4EAqjVavNoHSoz6eXZQSBZBcFlwgQp0EgkopQ0LVw+WOdChSQTJziP6FkAUAonn8+rlGQWcmazWRSLRdTrdfU7enzziY6bbnRJQcq6N3boZtIQlbbf7zd5DoxRMfuTigeAKXs0mUyqBBGmY0vvQMYvF+Malxr6uXJNMHFIKn35Pqvr4vrgmmTSCpU/k2vstG6s4CipEyAYDKK/vx99fX14/etfj4svvhjxeBy9vb2mRAjeYJkGOjk5ibm5OczOzmLPnj0qgF2v19Hf34/R0VFEIhGsW7cO8XhcKUNphUejUfT39yObzSruXdIZ3UAnAUyFGw6HkU6nMTg4qDypWCymBBYFUqPRUJ4Uv0dmhNGLKJfLqraHlBkAU7af7lXxPLsJPTZATzwajSKRSKhEiUAgMK+lDSk6Kigrw0RSo4ZxvFMHlRQVHOck64mYJcqYhpUlfjrXynshn5m5yfNoNpsolUqm7hKkgWXcjV0VmGItszhlcevIyIhKFAkGg8jlcmrO8Lwo7OW5rgQwSUgaOHrMUTcw9FgUadJIJIJUKqXKGvL5vBpLq++zExwl1QGkZmKxGAYGBtSjv79fZSNJaoOUTL1eVwtlfHxcKamJiQlVYEfqjoquk4XE/6W1002cTDyKBaq03vg3U1+pWJg2rQsoeb1SGUnBJLsknGhcOlGvywkpfOlx8lp4rZwD9HRYkEklpRsmupFAJdVsNlEul1VqP5UDv0dPU14sL0p+h1R6smibrzG+BsBE68pEC16zTAzg33KucR1GIhFEo1E0m02Ew2EAmOctriSPCpjfr/JkjDDdMNLnnv5wEidWKDweDwYHB5FOp3H++efjyiuvRE9PDzZv3oxEImGi98jr7927F3v37sXc3Bx+/etfI5/PI5vNolAooF6vo1gsKi+CVEd/f78SuuTbpVdGS4o91kh92Km2gZOcyikej6ui3XQ6rdLOmfpKYcv4nWyTxHGlt8TgLhNJSInlcjlVDKx3oJD0lZXCB5a3marevojxAXoRvA563zLpgdQVjRupuDnuMt2a31EsFpHNZlX8hx4slRO9p6Xodcc5K7uIuFzHUsp1Rc3sRZmuLulzlibE43E0Gg14PB5UKhVEo1FFW7F8w+12q7R0v9+PUqmEw4cPY2ZmBo1GQ3mPHG95/XaDjKXJ+0wF3amwX8oNGa+S32HVw6+Td2YXOEpKAy2PeDyO/v5+bNiwAc94xjMULSNjRjKjaGpqCrt27cLExAR+9KMfYW5uDsViUdEOwDHlx9T0vr4+xaNTiFl5TLQgaUXaKVvJKs2V3Ld8MOVYLh6mwNKjkl0GqMhlTRCpUPldukfVKYliOZWTFApybKzSsaUHRUOkXC6jVCopAU/KjpSXTM7h2MjCaHpSbCclu4VL72YxKL5O0Ocor1O36ulRUQFJZcXuI/QmAShFw0QRGne8DhoClUoFxWIRuVwOpVJJ/Yaeqm1HgUzoHq6VV9XJk+oEzhW9E4Xd4SgpAaYFRyIRPO1pT8O5556LjRs3qgQHCh62ncnlcnjooYcwPT2NvXv3Yt++fcjlcqoTMVOlZVLB8PAwent7sWnTJpxzzjlIpVKIx+OmzD3SPmyBsmPHDoyNjanUXTstLFr3zFhLJpPo6+tDT08Pksmkqo3Sm5tKKqvZbKoxIg0kLXIpgPgAYCpuBGASxlYCSMY1lmoMdRqOBghpTabc01jRqRlSWHKs6G3I75ZjI70WPvi6rpD0x1JBNxhkuyI+eN9572XsSE+z5uuSwpLv4/czUYAbAbI/oIzvUFB3KgrvNnRaUjdcZeIQ32MVk+Lf7OXIjD62w6KXzbG0kwEs4SgpgXA4jPXr16O3txfbtm3Ds5/9bJUqzEViGMfqVyYnJ3Ho0CF88YtfxGOPPYZ8Po9CoWCioAgKn1AohPXr12P9+vU477zz8JSnPEVl3HAhAVA0Yrlcxt69e/GTn/xE9V3Ts5W6CT02wLY+w8PDGBwcRF9fn/KKSPlQWLDhKYWFLNaUHhfHklmW9KiYyg4cX6T6otWV0XJZz3qMjgpKpp6nUilEIpF5HpdMt2dGVzAYnLdlSblcNo2npAXpoVspKFlfttSKir8hn+n9WcXoeC28TnqCpArlOHGeSO8IgNrmw+VyIR6Pq3owl8uFRqOh5qHs96crbTusLyvlJKm5TuyArqQMwzDVRDFjlLKE90L/PTuMAeEoKRy/oeyh1t/frzqYS8FJAZHNZnHw4EEcPnwYs7OzyOVyqjBSgpRVOBxGT08PotEohoaGMDQ0hHQ6regrvQiyXq9jbm4OmUwG2WwW5XLZdk1mAXM2HoWxpOX0rSMkdcWeYzJDTxasys7NVlSZpAyZfKIXReuKaznpHStFxZgU99Vic1kASlHzXHn9Ml4nqT2Z7UeFpAfD9fiFrrC7DSsPgNCFMXCc+qbiIuPA2Bsf9M5pHHLsSftJAa7H6OxIA3ai/k72HGWWJf8nOEf1tWInOEoKx1vu9PX14dJLL8XIyAhGR0fnZfDl83lUq1U8+OCD+PKXv4y5uTns27dP1UBJoep2u1Ux65o1a3DppZeip6cHT3rSk7Bq1Sq1bYVs9cMY1/T0NH7wgx9gbGwMjz76KKanp+cVXXYTkpqiF8WaKKnkKRhkken4+DgqlYrapE1ej2z7w+4C7ChPCoxUmc/nM8VqSONIYaOf81IHyqVg5ZxiPRRjnNFoFKtWrcLQ0JCipAAo6oUxKdlfjeMiG6lGIhGVEOD1epXSl/NIUmFWXlU3IAWtlbCUnhXvPePA7Pote9VRQTMOx61IeJz1hay7i0QiKhmJ3gS3M1msoubFgjwHqWikV6wbY1Z0HxUzlbVMwPH7/fNi3nZTVo6SwvG4SigUwuDgIIaGhlT/NIIeDrfU2LFjh9r+QKYH6wKKXQU2bNiA3t5erF27FoODg6bguYypMPB99OhRHDx4EHNzc8qLsks2kpUwlnQWkyWkh0hrV+5rRKEqv5cZb+wsoAsuLjQmXTBeIRWcvnCB5V1wusDlOTORhOnSHC8AKkVfxqFksoRsBMtnUmTcboPNeGU/RAk70VpWRoR8SO9ZClvSoLx2qaQYB2aWo2EYpg7x0uvmOLKThxTQdhHOEjplu5AXavVZPeuV3hPH+WRLOroBR0kByqJNJpPqEQgETMqDrWXm5uZQKBSU4KG3wP/j8bhqMLtu3ToMDQ1hYGAAW7duVRsg6u2NOOEY5zpw4AAef/xxHD58GHNzc7YIaOoWmqT5WPmfTCZV53e3260SPbLZLKrVKo4ePYrx8XHVGaDVapk8SUk7SMVHytQwDEWRkc6RwXjgeFAZsO6XuNRjJBUTi5sTiQR6enowPDys6u56e3tNWW4y0YHKRW67QVqLHgSTA0gfMm5TLBbh8XhU+rae3Wcn8Lx4/UwuYp85tgajEuYY0RCS4yLpvnw+j3a7rWhn9pKU9KBhGMr4k/HgpagfeyKQ5yUpO7kerRQ+k5kY4+RaCgQCpuQUdvWgwpJ0p10U9lmvpFyuY7uFJhIJtScUqSrguBXSaDQwMzOD8fFx1dZFKqloNIpIJIKhoSE861nPQn9/P84//3ysX78egUBAJV/IDDZ+P39jcnISjz76qFJSR48enRdr6SZ0S1fGoaikuMsqlVStVsPU1BSKxSLGx8cxMTFhop8ozLmwuDj43bSAmWpMJcXUfcJKSS2nwNE9ACZLsMN5Op1WW5b09/ejt7dXKR3ZBUJXUi6XS3mdfD+AeQXlpAvZYokdBZg0oI9TNyEFoEx+AGDKzEsmk2psWP8l+xWyNkzPBGTZR09Pj5pf9Fhl5wt6r2wrJePOOh3ZLehKinMMmN+7Uj5LhU9jhg96pM1mU8V/ZQKF3TzKs15JATClP/Mm6Tw+cNzjGhoawrnnnqu6ArRaLUXjcCfedDqttoonry69J+D4ouCOoxMTEzhw4ACOHj1qSpSwG6wSJrggZNBf1pFRyOrfw++gNyqVv0z7lx6RVNydKAp93JZSUVnFA/S0c8ZXSPHSe2CBM9OCGVuRwpmxN37G5Tq+iSDHiwq80WhYbomij1G355Uem6KiovAktc6/2dqpXq/D6/WqeKbsiG8Yhno/ADXvAKgxkIaEVFL8rExtt1tshspdZzWkYUYZI+cf1xX/1sfebglZOs56JSW9AtIjnNz0poBjN5+B74GBAVx00UWmSSOz2rjlguwiIbOugONCt1qtYv/+/ZidncX//u//4t///d9RKpWQyWRslyihxwpkZ+VEIoFYLAbDMJQl63Id6xpQKBRUkJoxAiosWneM2XAr9Xg8rn5PdkrQt2PQs9kWWmzLsRApILgdBxNKYrGY8jLpAbB4t1arYXJyUsXreIy9+xjYJqh4mAhAWiyVSilFVSgUVBKGThXZDbw2dpRotVqYm5tTrZ14/blcTtGYsmUWwTgTY3nMAqUXpRtVTM4h7cXv01tHdQtyvuqp4lJRSY+PcozxcHrz0qNyu93I5XKmbEnZtkrCDsbNWa+kJKQg5ESVE4LWKfeMokByu91qAsh2L1ZWD0FBzQ7VMzMzmJqawuTkpKmOo9vQJ6lMCpAWKYP70pMCjvdPk7y3LCCU1Bg5dFp+wPyO2p16z/G98nk5oQf+5bjwwTnB+y7781Gh0KNit3B66pLqYcypXq8ryk8KZXpt8jftRvkBnb0p6Q1xTdKj5FYtVFKS7uLY0tukl0qlDhynUPU5LFP47UDzSXSa17ynkvaWbbikJ8X5IEtqOiViyO+3w1w565UULf/Z2VlMTk7iwIEDynplBhktMQbxJS/MSaFnInXKvOHxUqmEubk5TE1N4b/+67+we/du1SndLh6UhPSkJM8vt/5mZl65XJ5H99FSo3dK4cmtPGjx6VtP8PPM3uKDHeVJhekdFpYz5drKy5T0MVOe8/k8arUaisUi3O5jW4Jns1nVWaRYLColJVPQef40imgQML6SSqXU/WCM0ErR2xEy9sMel+z0zyxOKjCOi1U2mlXshv0OOfe4TxsTb/T5IZXXQokJywmel4Qe1yZcLpeSUeyf6fP5VEcbGa+yotHlPDmZLL/lGhdHSYksn7m5OUxMTACA2ucnGAyaYib0knij9TgTv1PPkuFxPrNW6MiRI/jpT3+KX/7yl8o6tisoFGRSAxMZuHAokClcZDdr6XlSqcnWNUy40LPaqIhkRwV6IPQ6ZU+2TgtvKcekk6LidbAtjYyh5PN5TE9PKyVFz0l24pBWvfTOmJXFRAkGygEoj14WB8tnu0AqFgAqNufxeBQ1zPe1222llKUg1Vv6yMQTWTcGQHkUkkKWY0IPWCpAuY67Cf2arQq3SfP5fD5Eo1HE43GVKcnyBCp5fudCCsrq2vVkjeUYl7NeSQHHra9isYi9e/cim80qGo4xKElHyRonPrg42DGBz1xoBBfHxMQEHn74YRw9elQVH9o5bkBYKWRZb1KtVgGYG+PSk5K1KHoNkfQQZPCaSop0GLc60QsQrTyobowNx4fnRG+Qe2J5PB41HsViUe2WK7uWyCQJaeToxaZWAks/D10AdVvYErrxxgfXgL5/lry/fI80EuV9p1JiIgQTTRhzphK0opC7HYfqBJ1Klinmch7QqGYs1OfzIRaLqYJvPvTv5Xq0YiGkMtLvm5XHudjj5ygpmBXH97//fQSDQYyOjmJgYACDg4M499xzVRyKyRHsD8abQ2Hk9/tVx3RZEMz30fL/9a9/jX/8x3/E7Oysah5rx8UBdG5Zw0nMXmAUHuwTxqwsaQEzLiWD15FIBB6PR8VXZKYWO8nPzc0hm82ahLlsgWPlSQHzu0cv9pjonhTHRcadSE/m83kYhqE8qnK5rHqpsYO5bHxqZeXL7VpkqyhpDEkqiELYjsJXno9ULLyX0mjjfJBzg2Mi56L8nPwMMyCllyrjX7IprzQArAR1N6DHOn0+n6pL1DNk2T1naGhI0egej0f1/2T5Bq+LMoqZf3rMt5PCkp4m/6YRSizGmDlKCscHkg0Yq9UqotGomqg9PT0Ih8NoNpuWSgo4bjmHw2EkEglTirT8HdI52WwW09PTyGazqsZlJUEXCqRWONEpoEl1yfGgopKJFzo9Rk+CAsRKKenps8tB70l0SorRr0E2Nm2320pJMZOP4yfrfXT6RQoCwJxwwrGTn+lURmF3kI3otH7067AySOT/+hhYjclyz5vThe710NAj1et2uxXVy/6Q8j1UZJImlEkoTLzhb0mvaiH51MmDXyw4SgrHJynjKfV6HUeOHMHMzAwOHTqEPXv2mCq3GTehUPZ4POjt7VXWy+DgoHK75U2rVqt45JFHcODAAfzqV7/C3NycSs1eKZB0C70BWlO02hgvYZo4J6+k9phyzhRqjimFONPwp6enUSqVVCPffD6vvI6FdpollkrwWHlQ/D0Z5G+32ypGJzc4pMKl4lqo76AEBVJPTw9WrVqFgYEBpNNpeDwe1RmdXRfs2pOO0C1zCkKOgV60yuOy5lB+Vqf7rK7Vaoyt7qVueHR73KQHxZINPgeDQUXtJRIJ1QGmt7d3nvyhUuLnXa5j5TPSg5Jd9HmMRpRO0Uro475YHuiiK6k77rgDX/va1/D4448jFArhGc94Bj7ykY9g8+bN6j3VahXvec978KUvfQm1Wg3btm3Dfffdh4GBgcU+nVMCBQlwvCmj2+3G2NiYErKSSqHl4vV6sX79emzYsEFZtDL9VyrBsbExPP744zhy5IiKsXR7AZwq6NJTyAJQSoY76ZLukuPGXVc5PrIzOMeaFAy9DNb7UHFRwNObkh4V0FkwLQU6KSnOIxlfkbQn6VDpNUnBKT0oHRQybLEVj8dVwolMImFiiV2pPqKTouLfVoqCn9GPnazX2Ok9nRRUN6EnRliVNrBeMRAIqN2w4/E4EokEACgFIzfM5PrjmgOOjyEpQEmLyjgg36t7o5JCXGg9nioWXUn94Ac/wDXXXIOLL74YzWYTN954I170ohdhx44diEQiAIB3v/vd+OY3v4mvfOUrSCQSeMc73oFXvvKV+NGPfrTYp3PKkIPMG0JPR9b3AMcpFwAYGBjABRdcoJrT0v0GoCzrXC6H/fv34ze/+Q3GxsZWjAclBYm0+qlguQiYOMGCXY6hzDZjrRkpU44Tv6fRaCCXy2Fubg6zs7OYmZlBpVJRBcG08hbynvRzX2xYCQ4ZvJaGiVRGkv7spFzl+Uq+n2PHOERPTw96e3tVBhfvB5U542B6rM6OsLK4ZYadVBiSXteP0wAi9G4oUrDT0Om0P5sugLsNricqDj1DUfeQqIBkcggTKyKRiCr8lnE44Ni4BoNBNT6k19mSSq45qbhcruMNe3lvFmvcFl1Jffvb3zb9/9nPfhb9/f146KGH8JznPAe5XA5///d/j/vvvx/Pf/7zAQCf+cxncO655+InP/kJnv70py/2KZ0ydOtMr2rnM2tTXC4X1q5di+c+97mIxWJIp9OqJT4AJXinp6fxyCOP4H//93/VJLDDAjgZyEUr40LValVRTRwTCmoKbVb2ezwe1SiWCRP0RNkGp1qtYnp6GhMTEypFv1arqW7wjHXRM+0k3JcK8v7z+uQ1y/dIT0ku4E5JHp3A3wiHwxgYGEA8Hsfw8DBWr16tyiRYS5bJZJDL5VQ6uxQsdoYVdaTHOuQY6+Mms0L5fs4tNqSVxaxMx+5Uk2g3xS4VFNkerkHgOB3Ia5Xyh5/h+gOAoaGheXtv0TgvFovqNcaCyZLw/XIeS8UvvbLFik8teUwql8sBANLpNADgoYceQqPRwOWXX67es2XLFqxZswYPPvigpZLS0ybz+fwSn7UZVtYtcMxS4zbp3NSQHcCllVepVDA5OYmJiQmVmLESBIeEtHatqBk9Y0jWC9GKAzCPspAeGunDarVq2h+Ii4O0gx7IXS4FpUNmXEkPW3oAUiHplN6JhCC/gzE8uSU66R2ZkcVkDBY36wkYKw2daD0duhLj33r/RLmli5zLVvfEjmMmPRgWzss2YWzxpCeHWCVcBINBNUbSI+JnZTIOcCypQq49OX4LxakWA0uqpNrtNq677jo885nPxPnnnw8AmJiYgN/vRzKZNL13YGBAFdLquOOOO7B9+/alPNVTAm94T08Pfu/3fg/nnHMOzj33XPT19ZmEL2/q/v378aUvfQlHjx7Fnj17VpwHpQsKBlBJf1IgSu+CC0COB2Mp0WhUPWSXitnZWZRKJUxOTmJ8fByZTAYzMzNqa3RpwQFmJblc4FhIJUyLXY5XpzgL33Mi8Pvdbjfi8Tji8bgqh0gmk1i1ahVSqZRK9ikUChgfH8eRI0cwPT2Ncrls6206TgTdKJIUvE63cm7JLDZmuAUCAUQiEaTTaUWRGYahjF6plEhl202561QfY425XE5lvrpcLrW5pmzzRCNHlsLI9mV6wo9MnMjn85idnYXP51O9TNlVn/eCSk2m8C+2Ab6kSuqaa67Br3/9a/zf//3fE/qeG264Addff736P5/PY2Rk5Ime3mmDNzocDmPjxo140pOehP7+/nlp6bzxuVwOO3fuxNjYGLLZ7IpLN5fQA6X0kkgZyIUhKQQuGsYH2F+OY0RhW6lUUCqVVGyFC6ZTVwliMTnwTtDpJ91il+fE89HjjicT59AVIQVtLBZTnjs3TeRvsKUQE03sKGxPFadipUujgRm3bF5MSpSF1PRE9OQI6e3a0aPSww9UtF6vF6VSSR2r1+sqw1Z6jtI7CgaDymPiGqXxzHo8botiGIaptEQqPMmELFW5w5IpqXe84x34j//4D/zwhz/E6tWr1fHBwUHU63Vks1mTNzU5OYnBwUHL7+JkswNcLhcGBgawdu1arFmzBqtXr0Zvby8ikci8DK+xsTFMTU0pBTU1NaU6MqwkSGFhdVxSAPJBgRGPxxEKhdDT04O+vj5l7XHScxPEbDaLQqGgYir0BmRdFH/X6lyWElbxEb2YVu4Yqwe0ZbKEVcdpfr8UtEyKGBkZwdDQEPr7+zE8PKy6ntfrdeRyOWX8TExMYHJyEvl8fsUrqJPJrpOeuxw3lookk0lEIhGVKOByudScqlarCIfD82LDOi3bbcg1BpjjnNyuxOPxqD6Pk5OTqNVqSCQSioKnwci15nK5VMKXjEvJcgg+y/gqE030zFSZBagr+MUYx0VXUoZh4Nprr8XXv/51fP/738e6detMr1900UXw+Xx44IEH8KpXvQoAsHPnThw6dAiXXnrpYp/OooICamhoCE9/+tOxatUqrF27FgMDA/OCuq1WC4cOHcKOHTvwm9/8BocOHVrRXpTuIeivyT5xXFikYLhVRV9fHwYHB1UiBWkCZqVlMhnk83nVWYI1azqF0E0BogtG2UuPBZRUvrRU9aCzLhCB410iGH8KhULo6+tDJBLBhg0bsG7dOqTTaYyMjCAQCCjaJ5vN4uDBg8hkMjhy5AjGx8dVV4WVrKQ6Qc5DwOxBseOC3PIlmUwiHA4rg5gZqEzUYRxPUsh286T086GHxNgjcGwcqtUq/H6/MvA4/+QeZu12W80vfoZlHdx4k5AJFTJpg8pRGl1WGbeLNXaLrqSuueYa3H///fi3f/s3xGIxFWdikVkikcCb3vQmXH/99Uin04jH47j22mtx6aWX2iKzrxNofXi9XiQSCQwPD2NgYEAFIHWLo1qtYmpqCvv378fk5KQpPnAmQfeypJdBmoVUFfdYkrse04KrVqsolUoolUqmOih9sttBaADWBaCyJIEelewMIdvw6Km/pF2Y9RgKhdDf349wOIxUKoVoNKq68bdaLVUzxlR9dlNfaG+glQzdk9X/lrQrY1HhcFjNOdJVelNWwByPsZuCImTcTBY9u1wu09YmpP1o7HD+yZR1dpd3u90mephZs3zojZz1uJPskNJp7GzpSX3iE58AADz3uc81Hf/MZz6Dq6++GgBw5513wu1241WvepWpmNfOcLvdSCQSCIfD2LJlC573vOchmUwqGkGme5Ku+slPfoKvf/3rqm7lTEAn6o+g5xCJRFTG45o1a5BKpTA8PKwC2LTO2FliZmYGY2NjKBQKJoG7FJbZE4Eej5IeFTc5ZDxEJpVUKhXMzs6iXq+jVCopgcCYHpMvent7MTAwgGg0irVr16pxTCaTKlZQq9Wwf/9+TE1N4ciRI3jkkUdQKpUwMzOj2iytVINIp7d0pcRnPeWfyikWiynlPjAwoMaNWaZMr5aev2y7pW/h0W1Img8w98ujESQz8hiPmp6extGjR01zkdmxXJ9MxWcCBb+T84deZqPRQCaTUWMkGyB3UlLy3J8oloTuOxGCwSDuvfde3HvvvYv980sG1vvEYjGkUin09fUhFouZ6hF4g9kpgRNFVmyfyZDCm2mu9AzoCdCL4sSWm//JvZRWgqC1yjCjt83uGhQgpPxo8coMK1lLlkgkkE6nVZIEvVC2rqHVXCgUkMlkMDc3h0wmo6irE8XuVgKsDCGrpBUrT4pUFr0o1gXp3yM9kxO11rIL5LnJDDt2d6Gy4d9MctCVFClPFvvSw2SGKpUPGQ5ZL0XDUSonq6SJxRxDp3ffCUCBm0gksG3bNmzduhVbt25FPB5XNx843tBzYmIC3/zmN1X7I31PoDMNumfBJJdYLIbe3l5V3MwO8hQMVEbcw2t6ehr5fF7RfXYVGHocSSZP0JMKBoPo6elR3TTYsqhYLKqO8UwbluPm9XqRSqXQ09Nj2gRS7qVFL3Pnzp1qm5dCoWC5r9aZBCtaWVLLpEXT6TRWr16NaDSqsiAZM2EZA9tssaO+bCFlJy9KQp6PpPn0LhT0EmUsiokTUiHxNRlD1uPK/N52u60oQamQ9JZeSxUzdpTUCcDgfyKRwLOe9Sw873nPU56Bzmu3223MzMzge9/7Hvbs2YOjR4+umNZHTwRSYMii01QqhVgshmQyiUQioVKmWXjKfZRmZmaQyWTUzrR6lwQ7CQx5LlZ0XzgcRjQaVSUJ9KyktctAtexWQSVFz8kwDEWrsCVUoVDAkSNHUCwW1fxi0oneyWKlw4r2IyTVKuOf8XgcqVQKg4ODiEajauNSUqyyzohsBw2AlaDgrWKzkgbksxU9qkMqJKLT++nBW9X7LRXFJ+EoqRMgFothzZo1GBwcRDqdVoJHwjAMVd8j29KwfcnZAAoM2aWZDxmDYpYb2/YUCgW1Z5RsuWJnYQEcp3blQ27GyGugkQNAUXahUEhRM0yY4LPX61WWP7dxYdZjsVjExMSEScA2Gg3bBvsXC3osik1V2SqK6fosdQCON4t2uVxKkdODKhQKylCQXjtgL4PoRLA614WoUqvP6t9hpaikt2T1+aUeO0dJdQBv0qpVq/DiF78Yg4ODWLdunQqM667x3Nwcjhw5gv3792NsbAzj4+NnvBclPShmVoXDYcRiMcRiMUQiESVEGKRl7Gl8fBylUglHjx5Vf3OrCStFZRfhwfNgLz4G3pnOWyqVVF1Us9k0bV/CtF896E/+n4kkVNz79u1DsVjE+Pi42maeyRfFYlG117K7B/BEIMeJ646xYXb9DgQCGBkZwfDwsDIESN9RQU1NTan5RmqZG04uVaeEpYK+Jk6mpswKejmJ1fdIpkg+W53PUsFRUh1AARwMBtHX16cyhjpVqrOtTzabVXUYK2HCnyo6LQiZhi0f7Ocn6ymYNSTjAXLTP7spJmC+hcprkoF32UtNVv3rhb26kSPLF9gotlgsqj2hcrmcqhtjXIvjdaYqp07gHJP1aexewrUpi03dbjfK5bIqb+Cck2UOK0U5dcLpnrv+OSuF1Q2lpMNRUh1AqmpgYADnnXceBgYGkEgk5sWhKJgeffRRfPOb38TExARyudyKnvQng4VSsaXAoAKnl0CPaWpqSnXtplfQSXDYZSzledCTarVairqkV5TP59FuH9ulOZfLKWs/kUiY2vbIrRByuRxqtRomJycxNjaGcrmMo0ePqm1KuFUCCy5XCi36RNDJUyAtyngeAJTLZczNzam5KJHP51WR88TEhIkqteM8swPsNBaOkrIAF0EgEEA8Hlc7oLI3H8G4RKPRwOHDh/Hzn/9cFcedLdAVlWyMSiVF6oVeQaVSQT6fVxsb0pvSFZQdBbAMWMt9tZrNphKatVpNBfM5R4LBoKpRYTIFU3zr9Trm5uZQqVRw5MgRHDhwwETt0dOUv2nHsVkO0PPUO88zOYJBfhlHYesoJuro3T/O1rFcKXCUVAfIbsq6YgKgit2OHj2KfD6vLDS9tciZBpl1xYfs81Uul011Un6/H9FoFF6vF4VCQW1VMjc3h1qtpryoU9nIsNuQ1y6z9kht+v1+NJtN+P1+lEolTE9Pw+/3IxKJmOYVqc9ms6nSyGdnZ5Vykh0k7JwevdSQY02jp1AoqBpFn8+n5hITJmT9DulTsh5n+3iuNDhKygL0pMh1WxUAMjV4x44dOHr0KHbv3o2ZmRkViD2TIRUVFTKpr0wmg3K5rASDz+dTSordzev1OvL5vEoAKJVKSrisFOpF0kQs1K5Wq8jn80pJ6zEoPZNPJl9QsMrdYh1Bas4e47riHPJ6vahUKsqDZYcPvSOCTC7Ri1H133JgPzhKqgMogEulEsbHx1Gv11WHCaYbk0bgZoZyp8wzHXo6KgsMZdpvqVRSjWS9Xq9SXrKwUgqNlaKgCHm+erEkj+kb8clnWSxpVRh5NisnK0ijgIqcVDLHmGUOerseft6KSj7d7DgHywNHSVmAFEGj0cBDDz2EcrmMcDiMdDqNcDisBHC5XMbBgwdRKBQwMzOjBM3ZAp3yo1Bwu90oFovIZrPzPAe5DQCfqdhX8thxHKis5IZynZ6tlNFKU9TLCamkOM/YaUG+Z6E+co7yX3lwlFQHMM7AWJPf70d/fz8ikQhKpRLy+TxqtRpmZmZQrVbP6okvr122DOLeWbqAkMf0v1c6HCWz9JBdwKUxQFjdg4VSqh3YG46S6gAZa3G5XKprtd/vV1lZknZwJv8xSG9CHjvR3w4cnCpOxiCQ8VP9c53+d2AvOEqqAxi4ZnDb5XIhl8udcMI7MNMyDhwsJU5m/TlrdGXjjFFS8XgcW7duNW1JfzZj8+bN87YpiMVi2Lp1K2KxWJfOyl7YuHEjIpGI6Vg0GsXWrVvnjd3ZinXr1iEajZqORaNRbNmyRfUkPNsxOjo6b4wikQi2bNkCj8fTpbOyF0ZGRk5b7riMFWhm5PN5JBIJ5HI5xONxAEAul8PBgwdRq9W6fHb2QDgcVpvmEfl8HgcOHHDG6LcIhUJYu3atScDk83kcPHhQxdPOdgSDQaxdu9YkYAqFAg4ePIhKpdLFM7MPgsEgRkdHlSwCjqXJsyjbARAIBLB27VrTGFnJcSucMUrKgQMHDhysHJysHHd3fMWBAwcOHDjoMhwl5cCBAwcObIszJnFidnYWO3fudDjg3yIWi2HLli0mN3pubg47d+48qxrgLgQmACQSCXUsk8lg586dKJVKXTwz+4AJADIhKZvNYufOnSgWi907MRshHA5jy5YtSKVS6lgul8POnTtRKBSW/Xw61Y11E+FwGJs3b0Y6nT7lz54xSmrHjh340Ic+hCNHjnT7VGyBrVu34tZbb8WTnvQkdezxxx/Hhz70IRw8eLCLZ2YfbN68Gbfeeiue/OQnq2O7du3CTTfdhH379nXxzOyDjRs34tZbb8VTn/pUdWzv3r3Yvn07du/e3cUzsw/WrVuHW2+9FZdccok6tn//ftx66614/PHHu3hm9sHo6ChuueUWPOMZzzjlz54xSootivbv39/tU7EFYrHYvCw+jtGePXu6dFb2QigUmpfFV6lUnDES8Pl889iJSqWCQ4cOOWP0W7jd7nljVK1WnTHScLoMjhOTcuDAgQMHtoWjpBw4cODAgW1xxtB9Dhw4cODgOGQChd6BH5jf+9AOCRZWcJTUCoDeL9CBAwcOFgL315J/c2NIwLzDuN33cnOU1BLD2VDNgQMHywWpmKiQ2D/Q6/XC6/Wa9tTibsdsqG1Hg9hRUksIWjD6Dq069J1D9desthtw4MDBwrCits5U8FqpmHw+H3w+H9xuNwKBANxuNyKRCMLhsNqHq9VqoVgsolKpoNlsqh2N7bYxpKOklghSQelKyqrYTp8UVnveOIrKgYOF0Ym5sGOB61KA8sXj8cDn88Hj8SAQCMDr9SIajSIWi6HdbqtNXfkAjm30Cthvix1HSS0RrJSMYRjK9T6RV8W/uVW27mWdqYvsTIZVIFv+faIdZp19zI5BH7tOxp+OTuO5ksdVjzt5PB643W74fD6lnMLhMLxeL/x+P7xeLxqNBprNpnpIGWPH63eU1BJDBiilJ+R2u+HxeCwDnPKznFB6cNPxquwNK4FpdZ8XErJy7pyMt32mw2r8yFBQOAPW4yLHkv/Lv+26W+9ChqxVYgTjTsFgUCmnSCQCn8+nlBQ3cq3X68qjkvLFbnCUVBcgrR4rKpALiIpNfg6wzwJ6IljIkzhRmqzdrv9EConPFKK838y2knNAgoJDChFSMbrla7cxWSx0Uuy6cvJ6vab1JD+vJwpwHPn3Ql6EHcd1IU/S4/HA4/HA6/WquFQwGFRKyu/3wzAM+Hw+xezIeWjH63WU1BLDKjZFdzwYDMLtdsPv95u8qmaziXK5rBaSbmXbdTKdCFbeA8dDepZcOBQm9CipuHkM6K4Q6aRcpRCVwpSBbMYKSMFQyMrP0NpttVpoNBrK4q3X62i32+o1mUJsRwXeCQtRc528TI4PBTDjLR6PB6FQCMFgEF6vF6FQyGT4yUSBSqWCer2OSqWCUqmEVqulEgZ02qtb3tXJZATrc43KKRQKwe/3IxaLIZFIIBAIoKenR1F/Xq9XtXCqVqtq/tCrkkrdLnLGUVLLBKsFx4mlKykpqE60mO0wiU4FusDhGFB4Uwh5PJ55gkN6EYA9FJT+v359VveZtAvjBjRUpEVLgUrF5PF4TJb/QrUtdp8TC3me8n+rsaRC51gGg0F4PB6Vueb3+xGJREzrqd1uq/iL1+tVPS3r9TrcbrcpDVun1Pm3nbCQsSc9qEAggEAggHA4bFJSwLHdhAEoZS89ecno2AGOkloiWCkkCmAKpXA4bLKwJW+uexgA1HvszB9bQV9ILpdLLQ4Kl2AwiGQyCZ/Ph1AoBJ/Ph2q1ilKphHq9jqmpKZTLZVSrVZOgJrph5epxEfnM6/P7/UpgxONxFSPw+/0IBoOIRqMmT4poNBrI5XJoNBrKym00GiiVSmg0GigUCqhWq2g0GqjVaorKkrFPO86RTspd/1+OpVwzHo8H4XAYsVgMPp8PyWRSeQupVAo+nw/hcNi0fhqNhhqryclJFItF5HI5uFwupag4vvTYaRwB9lFSnWg+euVUUJQt8XgcgUAA0WgUgUBA0X1+vx/VahU+nw/ZbNa0Pq3KYLoNR0ktAXRXXFc4pCm4mKjAJJ2lC3YAJsFsJ0tnIXTyHmnZpVIppFIpxONxrF69GoFAALFYDMFgEIVCAbOzs4qW4bjW63UAy9/OxUpIAPOD99LCpwIOh8Po6+uD3+9HIpFAKBRCJBJBMpk0WbJULrVaDVNTU6jVakp41mo15PN5NBoNeDweFAoFpaB0CtROdA2xkPepH5fzhUYcjZdEIoF0Oo1QKIT+/n6Ew2EMDQ1hcHBQGTlyzdVqNZRKJVSrVfj9fmSzWfh8PpOCr9fr6jzkWOoJT92CFeWvK3J6mH6/H6FQaJ6SCgaDCAaD8Pv9KJfLah1KOSOvU/5eN6/fUVJLBHnjaVHLhRaJRBCJREyeEq1mq6w/+b1cNHalIwhd0ZJ+oKDx+/3o7e1FKpVCLBZT3DnpCVIx9LgosDle3fAoreJP8jqlsGCWVSgUQjgcRjQaVXQUj4VCIVPwWhopkUgEXq9XZWKR8ms0GiiXyyqG0Gg0FD1MS3ilzBEJOec5JhS49JqCwSBSqRR6e3sRDAbR39+PUCiEnp4eJBIJNeaSvvJ4PDAMQxW0cvyCwSBcLhfK5TLa7bZlIpM8N7uMoZVS16lQrjV6UFT0NHTl2tGTdqzovm5e/5IrqQ9/+MO44YYb8K53vQt33XUXgGMBu/e85z340pe+hFqthm3btuG+++7DwMDAUp/OkkJa1gBMXoOkJ2hFJxIJ0wQpFArI5XLqs0ya4HfT0rG7xQyYFRRpmmQyiWQyiVgshrVr1yIajaK3txfJZBLhcBi9vb0mjrxQKCAej6NYLKJYLMLv9wMAisWiitssl7WnKyX5N4UbhQMD11TGkUgEsVgMw8PD8Pv9iEajyqpl/IRChAqJ8ZNGo4FKpaLoqlAopJRTIBBQOwg3Gg3lEVBZSc/MbnPEygiTYykLUFOpFMLhMNauXYtkMom+vj4MDQ0hGAyip6dHGQL0Xv1+P1wul6I/a7UaisWiMnI45vV6HeVyWVF+jF1JJkM3CrtlFFkdt/I4o9EootEokskkenp61Hyj5yhTzylfvF4vms2mGgMpZyTl2S2DZ0mV1M9//nN88pOfNO0OCwDvfve78c1vfhNf+cpXkEgk8I53vAOvfOUr8aMf/WgpT2dJYbXgOHl0N5xxGNISwLEbX6lUTHGbhegR+bedhI+EjM/QwmXVeyqVUouJFnI0GjV5Fc1mE+FwGK1WS9EUMguu0wJermvTH5LOZPBat2p161bGrvSMRiaSUHACUB4mv6PRaMxLJ9YFqp3nCGE1jlw34XBYGXWpVArpdBrpdFp5VVxbHEufzwcAyrtst9vw+Xxot9smQ4Jer0zesVrHfLaLorLyeuS8k7Enrj3KGWY56qEDO143sWRKqlgs4g//8A/x6U9/Grfddps6nsvl8Pd///e4//778fznPx8A8JnPfAbnnnsufvKTn+DpT3/6Up3SkkFXTHwEg0EVMF+1apVaVCyuCwQCSjkxc4tWDt1xXRDyd+wseLhomGa/atUqRKNRDA4OYnh4GKFQCAMDA0rxkL6rVqsmnpzV8q1WyxSXs1vxIa9Xp3eZHMG4lFUGpxQgTH6oVqumZ6afA1AeVyQSUYpJpqZ7PB5TDzarFjfdGjc5n4HjjIOM6XE+MG7X29uL0dFRRKNRbNq0Cel0GrFYzJRkIxUNcLytD2N59EzZn65araJWq6m1JpmJTvVn3Rgzfd3LYwBMNHosFlMxOiryWCymxphlLcViEdVqVY0JaVAZdiBdbJcGAkumpK655hpcccUVuPzyy01K6qGHHkKj0cDll1+ujm3ZsgVr1qzBgw8+aKmkarWaaSv0fD6/VKd9yrCKTUg+PRgMIhaLKe6c1IX0FmRHCf1/+d0y+8au3pRcQFRS/f39SKfTWL16NUZHRxUdJtPMgeMpwVLoBINBdVxSEHaqDdJTpGUxJQPWeoq5btBw3Khwms2mSbjS6qVSCwaD6li9Xlf1LxwfKi2dIrYLdGUt4ymM2ZIOXrVqFWKxGFavXo10Oo1AIKBYCHqbcgz1tURPlApfp7zk2NhlrDqxJvKZ48aMxkgkglQqhZ6eHsTjcYTDYRMFzAQSziuZICLlC5UVcLzcAzB3uljOMVoSJfWlL30JDz/8MH7+85/Pe21iYgJ+vx/JZNJ0fGBgABMTE5bfd8cdd2D79u1LcaqLArlIZIFhNBpFPB5XcRjGIUg9cAHV63Vl2UlqR1IftGwWOge7LC6Xy4VwOKyy9latWoXe3l709fUhFovB5XKZMtaYDEErmtYfU4er1SrK5TJKpZLJS7AD5LhLJUqOn5Y705wBcycJHuNnmWZPgWrlURuGoepcmAno8XhQLBbV56R3xvOU/9sJcp5LJRWLxdSDSSd6FqQet5WedqVSUQYu504ul0M+n0ehUFBxKs5BaRzqj6W67oWO6x4Un6UxTMVO2UI6mckiUs7IhywQ141hK+9Nj0ktp7xZdCV1+PBhvOtd78J///d/q4X0RHHDDTfg+uuvV//n83mMjIwsynefLqQ1YxW89Pv9GBwcRE9PD5LJJIaGhkwxFQreer2u2uWXy2XUajWTdceJKBeRPpnsIngkN55Op7Fhwwak02k85SlPweDgoFpM1WoVk5OTqFQqKBQKKJVKyhr0er1K0NTrdVSrVeRyOczOzmJ6ehqFQmGep9nN6yUozGixV6tVtFotFS9qtVpqm4RQKKSuj5/lfWcnBCksdTqM8y0UCqkYFecTf4u/b5dsPyshq3uTnANMiOjp6cHg4CAGBwcRCoUUtSdjdyzEpXEnr53rinOoVqthfHwc+XweMzMzmJqaMtGqtVptXhcPHYs1biejoPT36B47M2UZr6NiZ2yX64hKmAqZCSNUVFLWAJiXOMI5qHucy4VFV1IPPfQQpqam8JSnPEUda7Va+OEPf4h77rkH3/nOd1Cv15HNZk3e1OTkJAYHBy2/k9aBXWC14CTNw/OVWUeMUcgbz0WmBzOtLBs9WcCOdJ+07licm0wmEY/HVdEqLXx6GHwwuO1yudRYyJZAuuVnB1pGz6CTHhItfN2CZdYmBYHMQKNXTcEhr08mRHCcDcNQwX/50GNfVgaNHeaMPpf1xBOZXOL1ek0KlqyCFbVHZVOtVpWSYhyK8RhJ98lO4BJWc2wpx+1kKD75ul7Ey3HS6y6lXNENK/mdnGN6WIHv7fT3UmPRldQLXvACPProo6Zjb3jDG7Blyxb82Z/9GUZGRuDz+fDAAw/gVa96FQBg586dOHToEC699NLFPp1FgW7RWMWfqJQikQhGRkZMtRvRaFSlvXJBsHsAqT7d9aYFLq0n2VuLQk63cLoFChgGcNetW4eLL75Y0X3RaBTFYlGl2R85ckR5RfQywuEwgOPjy64L2WxWFWNKCgxYfo+gU/xC0mu09vWmp+zH6PF4FCVH6peWLecDPwPAJLiZOCE9K3YuIZXabDZNafo8LztRflbGHWOYNOxkFh7XDpNrqKTJOshkAHpGmUwGxWJR9eoja1EqlZTyomEgG87K+9pNZW5FuzHWTU86FAohFoupGBR79+nXxXnH2jAm8tA4ohHAOCbpaj2JRBpmnXbyXewxW3QlFYvFcP7555uORSIR9PT0qONvetObcP311yOdTiMej+Paa6/FpZdeuqIy+3S6gkHycDiMZDKJSCQyb+IwJRaACm5zIumWnMx80usXOnHV3V5MVNbhcBjpdBpr1qxBNBpVjS5Jb5bLZWSzWeTzefVZKmX5fexfJwVQJ09qOa9d/y09bkT6jpSeDNa7XC7V2omGR7vdVu2OGC+gEpKeGueBLuA5doFAAM1mU6ViS0vYrp63XENSEUuvkEpZrh2OOceP3hI9KSpqGkKyhZSsRZOxv04x36WmSq2oPyvPCTguD2RZi+wmwbGjTJFeItcZWQvpieuel1RYUknpc0qPT3WiMZ8IutJx4s4774Tb7carXvUqUzGvHWFlzei8MDsikA+mBai3u+FiqlQqKBaLSmjTytO9BELnjKUwtAP1RYEaCAQwNDSEgYEBrF69WhUuA8eSIIrFIqanp5HNZpVFy7HiWLKIk9ZcoVBQfepkoarVOSzlGMjFqD/zd2Wmoi5Q2+22Uj4yI43Wu9W+PvwNCk8KYD0bkJC92xirYvq+bKKqt9bqRAEtNaTy1WlKGn265ygpY1rz+rhJQU5lze+w6nYuz0Vff8thDHUyPCV0ZU6FLkMLfr9fzTMrA1gqEsZ+ZW2d/jcwv5kzFR+/z4pGXGwsi5L6/ve/b/o/GAzi3nvvxb333rscP39akNYCFwXBSeLxeEz9xJheHolE5i0wTnY2t+RDNg1l5hqAeZ/j71qdT7chg94bN27Epk2bsH79egwMDMDj8ShlnMlkcOTIEeTzeczNzaFarcLlcimFzlZB9ATq9Trm5uZMdJ+eMiyxnIpKP64vVL1RqUym0D0i+X5dcFo1OZUCWwoJCi2ZZKBnEHaKMywn5O9TScnWPbJ8Q6buy1oofpbKXU82AqC8DXmdFOLSI9cz+jp5VIs5t6zGvtO94Htlb0gahaTJ2QGehjCTJDj39OJddkOXxgF/i4pdjrWcp3KbGL6uj9lirkWnd98C0CkS6XJLHl3vhKDX8cg9a0qlkuLEZfNQmb0nf19a6VYLyg5eFK1WKirGpTj5KURkIaUUrlII0ZIjDUMa52QKeJd7HKy8Kh6Xf/NZnxedzlsXVtKjopLTqScKMRlIpwKQSTfdUEoSVqyEnANWNVO8Jkl9A+axtbo+ehukt/gsEwx0Gs/qHsrf6hbkOOnjJq9ZJuRI5dTJc+zESuhUsvSk9CSepaRCAUdJzYPO/fKYtGTY3sjr9SKZTCp6hQKZQXAutmKxiGw2i0ajgSNHjiCTyaBaraJYLM7jjbkApbstrXFagiezq+hyjBUt+Hg8jlQqheHhYYyOjiKVSgE4NqlLpRLK5TIymQymp6dNHgW7NNMS9Hq9ihKdmZnB0aNHUSgUUKlUFlRSy3X9OvduRQ1ZUWiMT3Wy1KUA1i16OQ9JGTJTlIoIgNr0T6Ybyy7pzDi0EvTLAV1BSYUkd5ENhUJIJBIq8YiF31x/TC6RApjePOktAIrRYM9DGoWkQmXXCZmm38kIXOyxOllvSioNyabQKOH9lEYuDULee2mwMJtUN445bvwNqaSk5yTfR1hlRi6WN+UoKQtIS0V6Ulwk+sZisrUPKQgA6sYyWYDFhLlcTsWiODk6CTjJKcvJpHtU3QSzzAKBgIrNMYtIcuRUPqwPIu2gp87SCuR+UuVy2ZR5ZQd0osp0Wk4e75QKLN8rj1t5DDKoLRUmx1LSfjLmYDWfuz2WuhdFIcwyDmb4yabD8tz1NSOVPABT8gWFdCgUQrPZVOtWxquI5VBQJwsrr0k3pOV4UPZI5aMnZEmjxSo+J0MK0muS80nS1dKjWgo4Suq3kDdeKiT+zcVPLphWP5WHFBzSYqnX6yiVSpiZmVFKqlQqKTpL58KlRQfA5GFJZUZ0m+qjVc99obhNAjPz6vW6qu5vNptKodPzZC1VOBxW110ul1WhL+nBTgkTQPepmIXOQSoWUsPMxOLcIb3ZKRYilRu/Swp0dodn/IVxTqYdSwEPzFeISz1+VgrZSjEFg0FVshGPxxVtzHOnBy6z87h7sTTmaATJuLDf71eGIeOd+XwebrfbVArRDXSiYHUloFPrfNCwY/xR1hnq3wNAhR9k6YvVb1pR1XwP752E9P4X06B0lBTMi1a6upKOkJl8MnuKgobvlUqKk4FZbax8Z2cAedMBmCgZCiNdSXWKa3QDnKzBYNDUmZqBV8bd2IaGVAtwPGCbSqUUZcrxLJVKyOVylll93b7mE0GPi8j7LJVUOBxW1wVAeY+SZiYkrcV5wXiNy+VShgFRrVYRCATQarXmBcZ5jnxe6niCrhCt4lCyRor0XiKRUPtDcV7QYJGFu0wtp+Kil0DPkhSo3+9X69Hn86FWqyGTySjjgf0h7QYZp+P/VkqKHpTcZ4yfkwkpANRYytIO3VPjmEvjSNKGhmFYKinpjTlKapFhZbVIy4U3W25oJ5WZnjILmLsx65XtVlSCflNP9L8dIMeIY2JFQ0kKR9IzehIAvQrGCmgh2/HarWB1z3hMv17ArNSsLFHdy6YAZr9DZmlJikZ6TzrV18lqX+7YlBXVJ4UvBaGMh1AZyWcaPzzG99N74rPMWJNbWTQaDVM9lh2wkCyScoj3Vp9T/A59bUmqWO9yI9+r/yZwnPaTxrhUZpICXOy5dFYrKXlT9BsuaxFY0R+JRNSEp3Dg++PxOOLxuOn7mTIta6LoYsvf1+MYVpa4nTwoYH7gm2nPnKwcI8MwEIlElGCV6di0xqQwZqJFLpdTDUDZ0dsuMThCjy1JY0Me5+KlEKagAObXvMnYI5MD+F2ksvh57gwQj8dNQXQaA2zDpCurbo6jFH4UtrLWR3Zn0elQJtBwy4laraZodJ1xcLuPdfiIx+NqWxOpsEqlElKpFLxeLyKRiBLaTDTpJnQ5xLEig8MkI16LTM2XSl8mPcg5Sa9T32BTrmk9aYyhDv4v27kB5gSvxcZZraQIKwtCLiY93dzKQpU1GTLBQfackwvJSrjJc+GkkoLPTgKakGNEC0sP6uvj53K5lOKRkEJa8uUnSj1fKdCD3Facv/xbbyhMOhiAUlayPkgaV/oc5evdRCdrX49NSY+cY0Lvmgk47BZPZSUNOSopNixmSyUZZ5Z0mcyaszrPbmEhj1PvxiE9Hf2zunGr08dy7um/D5gznXkOlE/S29Jl1mLhrFVS+uK14sllmxa54yVfl++XbY/Im3MhsS5K788n0Yna04WZHZSVPm6MPwUCARQKBeTzeRUT4XhYNYqVHoaM7xUKBWQyGRQKBWXp2cmLlJAKgtAXL99HJcO4AQUvvW09kUbvQELlLb9TdhWgAOE9OZkxWwqhshB0T0o2kZU0HK9fbmUzOTmJYrGo2h3VajXMzs6q9SbXltt9vGMJ96BiPFDGwOr1+rxOLlbj0o1xknJIGnnMemQRL//nfGi326ZaOZ47KVJpNMsELqns9O4eHBs5VjImpbMHi4mzTklZCRNdQekWC2kJaXnpMSnZyoeToVwuq4fVQrJCp5iGPN4phrWckGPGQCypGGaWAccr/GWfNDkOHEPJlZfLZZVgImvC7KagFoKcV8Bxb6nVapkC1qSq2HWE75U0jfSsqtUqgOM79MrqfzmWukFzorFbqrGVFrccG6s4lCy0pfdEb6larWJmZgb5fB6lUkkpqUwmYxK+ch1zLhmGgVQqZeqhKctHrOKE8u/lnndy7ugept4KidfEkgOv16u8Ro6jVFIyNi4fBMdCFlDrnrpUZHrcdClw1ikpYiHlJBeQ5GEB82LmZJcxKmkx616DvNmdLDZdoHSKR9lBYHNiMuXZ7XZjbm7OxJ23223lJTBjT1IypF4ohPUkE/lbKwVWcURZzEvBQ+qKr+lduOW84ZgxE0vOJRnM1utiJGUmP0PhtVSChVjIutYpdUnx8Vqr1arK8mS/R3pTsu8l54wcD90D1ykqPQGhWzSf7oUsZFToc0uGFeS957oEoIwdXTHp88uKvZFUnv7bgHXNmkP3LQI6JUmQ3tNroawyf7iw2GuOk5wWi/QsZOBf0kD6xNQnmZwY0lKxg8Dm+TSbTZRKJUxOTiKfz8Pv9yOTyaiuHIZhqFoWepUej0d1bGZCiqRF2fm8U8NdO0MqGOB4MTYVuZxjFLwUKHqpge5BSuUu5xKtXvk9PBddGOmKilhOj0EKQJ4/kwCkcnK73cjlchgfH0elUjHRfbLvpbxGXgvXJg0lGQtmhh/r1az61+ljstSepnzWocsJdrORjASvXTYs1qlh2QFeJk1wruqyhgakPp9lbRXPbSkbDJyVSorQ6T6rQK6VlSXfKwXEQgFJ/aYtZLVZWSZ286CkBcW4k8vlQqlUUnEGeg6kpFjnIgtQ5ZgDmCeoVxKs7plu7UqFQ09bXq/8Wx8DPelGMgBSwOpzxA5zZiHI9Sc9KY6PbPEkH7JeSo6NFeshjVKrtHyrz1j9v5Sw8qj0ZyuPRmde5BhK6PPMip3RPXS9v6H8DXmeS+VFAWexkpL8vQxOcquIcDisCk/1G0JPwO/3q605MpmM4scl/cAFJOsI+D0L3VCdplmqCXC6kIuFXSUqlQoAYGZmRo2lfC/B3mz0VtlzjQpfJlusFE9KKm4KAypoWr2GYZioLTbQ7XSvJU3DOcS5GgqFVM9DWVukK3sA84SyPGc+L/UYWwlgKShJPXI86IFnMhkVn2QyDVkK0qR6vQ+pd3qtMskgFAqponyr1kDy/JbLMJRjI70YzhHGmpilSOOvXC4DMGfc6QX/Us7Rcye7o3tiVp4m0/c5trJnqDSq9L3eFhNnnZKyCuBKz0kW7DIYSW5Xfk5mCAWDQczNzZkC/VaWju49dXLtO3lRdgPPTdIzhmGgUCioMZTCUfbokzEBHuODVNdKi0lJoSbpF9K90gN3uVzzWmPp36XHEjg/9cC/7BDOOSaFlFW8ZTkEsIy7WkG33DmXJG1OirhSqagdBOReSfpak9dEgSs3CJRdGuT61GMyyw1dRkhFAMDkXZPy5d5ilF/yfRxbaaDQKJKK3UrOyISWYDCIVqul4sZW8kl6aI6SWiR0ovYoMLnoAfPeUbFYTHXtTiaT6r1WLrOVYpI3VUK/4VaWtR2hew8ULFQybPMjg+LAMQEqixPZqVp+Tt/zZyVBjodscwWYvRpZ97QQfSItYgpbZnbJBqzSqpXGUidKZzlhpaikIJYp0ZwrbrdbeU2VSmVeVppuBHI9c25xbzc+GH/i98tOFXqCUzfnnW7keDwelbloGMd3fZZUXCcqE4DqZSjng4yNc43S4OG6pEfKc5IySqcOrYysxcJZqaQIq0Jd9p6jZcL+Xz6fD729vQiHw2obAbrcdL+lEKbVIVM4+Rpb2+hWr+SR7ZQksRB4fvK8pQEga8h4Te12WwkRChLSD6yJId1n9+uXkAqF95hWK6kSPX6kB6B1hSLHkp092JkhFosp4et2u5UnL7dJt4pBWP3OcqAT3WdVs8P3sCbKqm+fTmtxjFg3FI/HkU6nkUwmFb0sa/Lk/mayeFw3GJYTuqyQdCQND8osXgNwnBXiFkL0GEnHk0KX1LH0wDi3GOpgOMPKeNYpvqWuYzxrlZSkIqQ3JR+yLkHudcP/9QC3lQXcibrrZDnL11aKgLa6Fvm/VGB8TdJ8MkNIFz7699sRFJL6MeC40pYeZyeFpB+TWV+davc4hvysVeKFVbylWzgR/UjwnK3iRvoc08dHeuhyuw96UQBUPEvW7UmGoxtjJJkJQsazJdMAQHlXkhmih2UVapDvk0W5AEw1alZdP/T70ClxYylw1ikpOcklPUDLgV4T+2PRavX7/ejv70ckElE3k0WYDEZKK0/WSVltywHM323XildfKZDXxP+56Gih+nw+AFBp57FYTFl7svhZ58xXIvTxAGBSyHyP1f3muNHqJ8UXCoUQj8cRCoUQi8UQjUZVMScFCT1RpvFbCWIro2mpxkAqWoLCUhbF8zgFJEsQ9Gw+fV7IPbTonff39yMcDmN4eBirVq1COp1W/Q35vdw+J5vNmortu20c6YpK3i/eY8ouJnfJek093sb5I49xzNrttpqTfr9f9UwMhULw+XymLvOyPIRjRWp/qRX8WaekJHTLQlqqFArcVoEb+rFZKkGhoAdwO/G2cgGspPjTyUK3AmU8Rlp1sg8i3ytjUStZQREn8qIXUha6p693G5CJAHIMJXUmYzjLqZwWgn5dercH/q9b8FaUkozByE1IuU5jsRhisZhav8xwIwXGhAw55+wEfS0RTJiQXW84ZrwOUs4A5sk2rknDON7+KBAIIBQKmZLHZI0fk1WkwaOvU4fuW0RYCQkdnOxUUrRQDON4T7FyuYxsNot8Pq/atTQaDbXBH6vhdSWl87zdFhxLBX2cZV2Z3iATgKlDx0obDyvKT4ek/gAznadTe7SAWe4QCoWU4A2FQiqdmrEJWr0UvHoygJWhtNRYaDykgSj70VGg0oAJh8OIRqPK4+Zr3KqEn4lEIsrTHB0dRSQSweDgoNqIk3OK3jp3fJYJGXYxFvW5JL0rSReT7pO0uVxrnD/0skKhEIBj85Bb5ujlN1RuVEyMbeqtzZZzTp2VSgroXDDLwQ4Gg4jH4yY3mJwvrbBisYi5uTlFGTBwzZ0+mQxg9ZtW1N5KEsonglxocuFI7ltuC07lr3dHX6ljIpWPHAcA85QSoXv1FMBUSpFIBPF4XAlubo3COVmpVBT1vFCqsTyXboDXLJWxrF+SHV+q1SpisZjatFBa+F6vV70Wj8cRjUaRSqWwadMmRCIR9Pf3I5FIKA+DBmShUEChUFCKSm9ibAfoVKmkz/k61wrHSioOjqvs5kGFJmlm2RpKlpBwLeqUsSxA15mgpcJZq6QAdPRw9Nf03mi1Wk3VbJD7t7I4pCIidKvDDkJjqSFjEJKm0jt2d2rhc6ZC96o4RrJpsUwEYE2eTDs3DEPNt4XoGCsPoVsxl05MhvQKeG30jphGzQa7jK0wrskYXSKRQCQSUdt0AObt0sl6cIsPWTBu1/kmx0c/ZmV86ApNp1jla5Jele249IbQVpTrco3ZWamkqGw4QfUdYHmsUqmYWtbTupibm8ORI0dUzzpOeKZ4yoCifhOtrFm7Lo7FgKR1QqGQSgeWm9vRyqXCl3skrURYUX/6gpZeE5WTjD3Rm/B6vUilUojH44jFYujp6VGdAPx+vzKYKpUK8vk8stms6hout0iRFOpyja1u+euv6enL7Lcni8Cj0Sh6enrUthtsq0VlxtonljMwcYL0fKvVQrFYxOTkJMrlMvbv34+5uTkcPXpUbfNBj9NuisqK9pPPpP7kcdlbT1dcsjZKKj4aOmx2zLBFuVxWXhWPdWMunZVKipCBfd1CkEWD8pjuSck6C1nIqrvBVmnH/P9Mh/QSZCskqzRXfXGtVJwoPsX30JIl5SITSkjX6F4UaTFaxbR4ZXDbKmHHTuOp0948N333ASZDkN6r1+umLXMkJUrKkAkAcj8qrtdcLodsNotSqWRaszwnu0Gn/Tq9x2o85TE9tV2XR1RuktKT2clW9VDLtU7POiVlZZ3Q+2G6tMvlUmm8vCm0ygzDwPT0NLLZrOpyzuAr08xP5kbacUEsJmQ8hpZvOBxWHgFT/lmvAWDe2K00LCRIJPS6HrfbrTwCuTEfyx16enqQTCYRiUSQSCSU8qLHzzgUYy1MqV4oU7KbVJ/+qNVqKBQK8Hg8qFQqMAxDzRG5DU4qlUK73VaKS2a2WcU3M5kMisUiZmdnsX//fpRKJYyNjSGbzSKXy5mSJuw833SPVPekZA9Dl8ulisY5x5imbkUL8m/GNJkQxnhUsVic1yNxucfqrFNSVuBNIKXndrtVZgv7XUkllclkkM/nlSIjzSfpQuDMV0Qngi6MWXNGqoq0DrBwpuVKgx4L0OMDshuHzKySBeNMBvD7/Uin02rTvlgspja2k6nU9BRI/ckGonZLCNCtfjITTJTg2NBrjEQipixQxujkdxJcy81mE7lcDjMzM5iensbhw4dRLpcxMTGBfD6vqOVuZD2eLqRXxf/JQNAgoZKS84wGuP5d8h6QbufWO7LeTrJI/Oxy4qxVUvpioTvLFkelUkmlvLIIlROBk1xmBa2Uib7ccLlciqqKRqMqC4vxFr2mzO5W7UI4kRdllSRB2pOeJbP42GGfmW9yvyV6H4wbyCJL6UFZxQ66NUetvAHZColCkUqqVqspj5JjJilRmTTCZ65fbog4NTWF6elpzM3NmRSTVV/DlTLnpKKSnhTbJbE2iuMq+/Ppyk1XUjS29djTQkaOE5NaIkh3GYDqcs7/PR4PSqWSKbvKMAyTG0wlxhu70ib7UoOC2OfzIZVKIRqNYtWqVRgdHVWUXygUMnVGkEHsMwGcD1ZeFDMdqZDS6bTylBKJBHw+n6oPYi81AIqCptDN5/OYnp5W21rweK1Ws4XxZEWvy7quRqNhSpTIZrOo1+uqH6HL5UIsFlOJN3IfMlnoK3ftHR8fV0kSk5OTKJVKyGQyqjzEKjXf7pCxbSm/pBKhQpKNYanUWarA91Jmydg754zs7qEnlMixWq5xOyuVlISVN8Ub2Wg0lLUvlRSD03YOTNsBUlHJXmqybkNacyvdk7KCTv3xb6stYmRneP4tkwhkJiq9Dip5Cnyrbt4S3R5bfb2RnpIdyb1e77zu5DIRhN8j++9xK49isagK63O5HHK5nBon2YXDThToqcBKWckQg2QmZENjqaRk5jHlnZR9neZPNxQUcJYrKbrLVhsTypYtLICTPL9VkoSDY5CxKJ/PZypCpYIib06Kit5pqVQyFUCvBOgKSP9b3z7BqkmsVcNdACZqj5tLNhoNlaGWy+UwOTmpkg9kxppeo9ctWMVSpDVPdsLr9ap92ZjJx5IE2aVbtuvJ5/Oo1+vI5XIoFAooFosYGxtDtVrF9PQ08vm8iivzM1JBrdR1K8dUKn69fEPKNKns+T7+fzJKSv7ecuKsVlK6G8uFbVVkKV/X02ZX6kRfSkhFJfsfMq6gW9EUSLJOaiWMa6c4lD5/5HHWQ1l13SdlAxyfnxSs1WpV0WFSSc3NzansrE77SNkJupLi/a9UKoqOC4fDan4AUPQoDRx6XtlsFrVaDblcThXpjo+Pq8w0qZys4nMrGbqiAo6HLGR9IqlAqYiseo3K0hl+vx1w1iopq0DuiSzibtQIrGRw3Gq1Gsrlssq2CoVCigbkluBzc3Oq7mwlxaT0eSOPA8eFBoUEPSM5h0jrUUnXajVT6jBpqmq1qmIrFMAcM53Kkl6UHeao7k3J2h1mn5HN4DY4mUxGFS7LHnTS8qdnyZhUtVpV3pPe2fxMW7fyGqS3dCqelBwbu47TWaukAOuODydDkdjhxtkdtOTa7TZKpRIAYHJyUjUDbbVa8Pv9mJiYwMzMDMbHx1VdCzMsVwp0g0d/lkKCY8L03nK5DI/Hg3K5rGJ29CJYQya3q8jlcvOKLDleVntx6efZTegxDY4bew263W7k83m4XC6MjY2ZUvRldh/nFmNzHAPSnDoVr//2Soc+jjqVSg+KlDrnplWz4U7fqR87mfq/pcJZraSscCZN5m5CWmf0DIrFohKyzNTKZDLIZrOK5qGgXWno5FHxNcBs7UpwnyMZC6CgAY4rKdZE0YuQ8YSFhLLebaDbsPKqeJzQa32kkgJg8sJklh/HQ/++MxmdFIyk/gB0nCsn+s6TOb6UcJSUg0UH4w2kWyYmJuD1ejEzM4ODBw+qhqBUXKzzyWazppjKSsNC3ouMUVkl51QqFSWImTxBgSyVEb0mnZrpRNF00wJeCLrlrytwq5ieHt/Tkwb0cTibwHGkt85nwLol26mO00JG2FLDUVIOlgSyhoNWMetV5H5BMm2adM2ZKGg6KRAZt+MxWYDJzyzkdaz0sToRJadTqQ6scSZSm4CjpBwsIXRBKmszpMVn1Qz1bECn6+TYWAmdhQSRHeNQi4Ez4RrOBHTrPrhP/JZTx9jYGP7oj/4IPT09CIVCuOCCC/D//t//U68bhoEPfehDGBoaQigUwuWXX47du3cvxak46DLoTcnWK8xKY2NUfV+fswk6XSeLLfUt4Dt1Nj+bFLuDsw+L7kllMhk885nPxPOe9zx861vfQl9fH3bv3o1UKqXe89GPfhQf//jH8bnPfQ7r1q3DBz/4QWzbtg07duxQ7V9OFbFYDJs3b0Y0Gl2sS1nR2Lhxo9oumohGo9i8efO842crNm3ahHA4bDoWiURwzjnnqPY7ZzvWr1+PSCRiOhaJRLBp0yZTTdfZjLVr184bo3A4jE2bNjnGw2+xZs2a05bNLmORR/EDH/gAfvSjH+F///d/LV83DAPDw8N4z3veg/e+970AgFwuh4GBAXz2s5/F6173uhP+Rj6fRyKRQC6XQzweBwBks1ns27dPcftnOyKRCNavX2+aGLlcDvv27VO7m57tCIfDWL9+PWKxmDqWy+Wwf/9+VCqVLp6ZfRAKhbB+/Xq1zoBj62/fvn3OGP0WwWAQ69evRyKRUMcKhQL27duHcrncxTOzD6zGyEqOW2HRldTWrVuxbds2HDlyBD/4wQ+watUqvP3tb8eb3/xmAMC+ffuwYcMG/OIXv8CFF16oPnfZZZfhwgsvxN/8zd/M+06m4BL5fB4jIyMnvDgHDhw4cGBPnKySWnR/fd++ffjEJz6BTZs24Tvf+Q7e9ra34Z3vfCc+97nPAQAmJiYAAAMDA6bPDQwMqNd03HHHHUgkEuoxMjKy2KftwIEDBw5siEVXUu12G095ylPwF3/xF3jyk5+Mt7zlLXjzm9+Mv/3bvz3t77zhhhtUR+NcLofDhw8v4hk7cODAgQO7YtETJ4aGhrB161bTsXPPPRdf/epXAQCDg4MAjrXIGRoaUu+ZnJw00X8S3OZhIczNzWHXrl1OvOW3iEajOOecc0xudCaTwa5du5xYwm/BJAnJk2ezWezatcuJJfwWTJJIJpPqWC6Xw65du1S7q7Md4XAY55xzjmmM8vk8du3ahWKx2L0TsxFCoRDOOeccUwLdyWLRldQzn/lM7Ny503Rs165dGB0dBQCsW7cOg4ODeOCBB5RSyufz+OlPf4q3ve1tp/27O3bswM0334wjR46c9necSdi6dSu2b9+OCy64QB17/PHHcfPNN+PgwYNdPDP74JxzzsEtt9xiMo527dqFm2++Gfv27eveidkIGzZswPbt2/HUpz5VHduzZw+2b9+OPXv2dPHM7IN169Zh+/bteNrTnqaO7d+/H7feeus8WXi2YnR0FDfffDMuvfTSU/7soiupd7/73XjGM56Bv/iLv8BrXvMa/OxnP8OnPvUpfOpTnwJwrHr8uuuuw2233YZNmzapFPTh4WG84hWvOO3fLZVK2LdvH/bv379IV7KyEQ6H53mVHCNHuByD3++f51WWy2Xs27fPES6/hdvtnjdGlUoFBw4ccMbotzAMY57n7YyRGa1W67Q970VXUhdffDG+/vWv44YbbsAtt9yCdevW4a677sIf/uEfqve8//3vR6lUwlve8hZks1k861nPwre//e3TrpFy4MCBAwdnJpakLdKVV16JK6+8suPrLpcLt9xyC2655Zal+HkHDhw4cHCGwCkZd+DAgQMHtoWjpBw4cODAgW3hdEF34MCBA5vCapsSfU+tMx2OklpELLQp2NkwmRw4cHD64P5i+uaO3LaFGw/ysdDWLFabYK5UGeQoqUWCPqmIlToxHDhwsLyQCogd5uXW7wBMuzkvtEULt3QhqOBWojxylNRJQN+GWbd4dOtHTizu/cNtsZ29fxw4OHl02kZeHtMZDCsPYqFj3QaVkt/vh8fjQSAQQDAYhNvthtfrVa/zf/max+MxeVa1Wg3NZlPt29ZqtVCr1dRzrVYzbUBqp3HoBEdJdYCVZ0QLxu12q8mhTyL5/kajgWazadry22r7bwcOHJghFZFcd9LTkOuP0NeY3EzS6rnbVJjL5YLH44HH40E4HIbf70c8HkcymYTX60UoFILX64Xf74ff70cgEFCvRSIRBAIBJY/a7TYymQwqlQoKhQIymQzq9Tqy2SxqtZrqfdpqtVCtVk3elp3lkaOkNOjKSV8QHo8HXq8XPp9PWT+cJFRSnPzVahX1eh3NZhPAMc9KV1pnOxaK43WiUIkzhXN3MJ+dkEagXGtcf16vF263Gz6fzzQ3KHi51rijcb1eV7tD81iz2TQpNWD55xBlBz2kYDCIcDiMSCQCn8+HWCwGn8+HYDCoPKxkMgmfz4dwOGxSUq1WCx6PB9VqFYFAAF6vF7VaDW63G9VqVXlQ3AWbYyBZHjvCUVIwC0DpDblcLvh8PnXDablEIhEkEgn4fD5Eo1Fl5fj9frRaLZTLZTSbTWQyGRSLRVQqFWQyGTQaDZTLZbVgqLzsOjkWC7pVbPUa/5b0jbScKbQIqfA7bal+tuNEcdJuj5F+n+kx0KsIBAKIRqNIp9MIBALo6+tDOBxGLBZDPB6H1+tFIBBQXgQFLxmMTCaDUqmEUqmEubk51Ot1ZDIZVKtVlMtlFAoFkwJbTs+C1xwIBNS1rlq1CrFYDLFYDMlkEqFQCMPDwwiHw4hGo4hEIggGg0ilUvD5fPD5fCZPstVqoVgsolaroVQqoVAooFqtYnJyEuVyGZOTk5icnESxWMTY2Biq1SpKpZJJgXV7TljhrFdSVgtZek8ejwd+vx9erxfhcBjBYBCJRALpdBp+vx/JZFJ1aQ8Gg2g0GigUCmg0GiZqsFKpwO12K89qJQcyTwWdlI7+utVD0qqSTpXWLwUTj7daLcu0XTtgIa+RWKxz1uM3nc6jmzSXvt7kWqNATiaT6OvrQygUUkI8mUwinU4r74NKih4S4zJTU1PI5XIoFArKw2i32/B6vab4DYXzQllzSzUGHo9HGcKRSEQpqVgshkgkgt7eXkQiEcTjcUSjUQSDQXXtZHZ4vq1WC6FQCPV6HZVKBdFoVPXvLJVKynPyer3IZDIAgHq9rpS0XXHWKylCp/ak90SF1Nvbi3A4rBZOIBBAKpVCIBBQnhSVVL1eRzKZRKFQQC6XQyAQUIrK5XKpiSH58TMJUtlIaob0KI+RxvD5fAiFQipwTCvR7/ebhGq1WkWlUlFce71eR7FYVN4rA8N2oVStMrZ43Ap6nGQhr4eCVf8t/Xfl67rFvNyGkjw/UuShUEh5FL29vQgGgxgeHkYymUQikcDAwAACgQB6enqUoRgOh9WccrvdSkFJJeXz+ZBMJlEqlZBMJlGr1dDT04NSqYSZmRmMj4+jVqshk8mgVquh0Wig0WjMW5NLMT68dlJ58pFOpzE0NIRIJIL+/n6EQiFEo1GEw2HlQbnd7nkMAunMRqMBAMrL7OvrQzweRzgcRk9PD7LZLDweDwqFAg4fPqyUl/w+O+GsVlJWC5oWOz0jLpJQKITBwUHEYjGk02m1cLioaNk0Gg3kcjn1XCwWMTs7C5fLhWKxiGq1qrwscsNnIj0lx9Ln8ykKJxwOq4Cwx+NBMplENBpFKBRSxkAsFkMwGITf70coFILL5VKCNZvNIpPJoFwuY2xsTAkc4JhVyAVH4dstIUxYJdvI9+leX6fgvn4des2M/C39mPwd+d3ye5Z7jGR2Gj2IZDKJtWvXqr3QBgcHEY/H0d/fD7/fj0gkYjJapOKXcSZms0WjUdTrdVSrVRSLRdTrdfT29qJUKmFsbAwulwulUgnNZtOU1m2V6LRU10/jTD7S6TRGRkYQCoXQ19eHYDCIUCiEYDColDsAU7yb51qv15V8CQaDaLfb8Pv9aLfb6O3tRb1ex9zcHNrtNrLZLCqViqII6/U6ANhOUZ3VSkpCp5iodGi50AuQWTbS4peuNy0YqYxSqRS8Xi+i0ShKpRLa7bZaYO12+4yh/qRw5LjE43EEAgGVtcRYntfrRSwWU9ZxPB43BYRpZUrBz/Eul8uo1WoIhUKKW6fApZXZrWvn39Izl+nEMm1YKikKGhlfOZFVb+Wxcg7Lc5LfKanSbiQK8PyYuZZMJpFKpRRDEYlEkEwmFeVFI5DjZhV/lEkStVrNlCQBAF7vMVFHD4yUGj05jgu9EP7GUlGjuqwh5UfjzO/3m5JCGDuTc4SMAr3jdrutvEh+h5yH9MBCoRDi8TgMw1AemsvlQqVSsWUYwlFSMC8cKphQKKSybCKRCEKhkPo7Go0iHo8rS58Ulszya7fbiEQiaDQaSCQSCAQCKBQKihv2eDyKolpqamG5wYQTek7r1q1DIpHA6tWrsWbNGgSDQfT09KiFSOFKIU6BRL5eZlEWi0U1jn19fSrewGBxuVyGYRhwu90dKbKlumY+S0XE+cC5RSFBAURDhXHKZrOpBC4pYQog3eM2DEMJObfbrbxUCjyp4KrVqhJg9Ez1xJ2lnHscH97TYDCovIR169Zh9erVSKVSWLdunaL9YrEYAoEAQqGQup8cF14La4HoQdCb4NhIAc0H41LAsQ1X6/U6crkc5ubm1PhLRb4UYyNjcJQzjLUlk0nlNVKWlMtldW35fB6NRgNzc3MoFotoNBqo1Wrqe91utyluTlnFEIbH48G6detQKBSQzWZRrVYVO0Gj2k7sjqOkBCRFxcVPYSmFjX5MjwXI4x6PB81mE9FoFACU284sJjsHLE8H0qonTUFLua+vD0NDQyYlJRMiCKt7wAC5pBDz+bwS+nwfx10/p6WMwVhReDp9LK+FMUx57RSMjUZDxVhoMVOpAJg3Xyj05fdSIPF7qazomVHgLzROSwHde2BsiVQfHzQI6U1LSo/eQqVSQbPZVHSdVFK8ZiZh8CGpMiqGVqulxk16ovIeLoV3oc8R6VHJecz7zVhTtVpFPp9HrVbD3NycUlhMkKBcId3XarUQDodN848UY7vdRjgcRigUQqVSmbd+7OJRnfVKSqdodIEiM8posZHnbrfb8Pl8JoHC9+pCgJMimUwq62d2dhZut1stLn52JYILjtba8PAwNmzYgGQyiSc/+cno6+tDT08Pent7TQkRrIKv1+uKBiWYpELIQHO73UYoFFIB8oWSBuS9WC46QypTCmRSnYlEAsFgUF2LYRgqnlapVJSHLTOyqGDo/fB6mHDg8/lUYgGVFCmhZrOJubk5lX5NOkwfo6UEf8vv9yMajSIajWJgYADRaBSDg4Po7+9XsUmWcrBrAhUsi1KLxSJyuZzygEjr0Uvk2KfTaUSjUcRiMVNRrPS8GROr1Womw0FPOpFjvhhjxfPlvHe5XCiXywiFQiiVSigWi6bfy+fzikGYnJxEtVrFzMwMCoWCGh/ppSeTSczOziIUCmFoaAjhcFhRqo1GQ3lxyWQSg4OD8Hg8KkaVy+VsFSs/65UUIWMp0mvSlVSz2USj0VCUAhcUaQL5XbTM+L52u41YLIZEIoFisagoGRm0XckgzcdMyHPOOQe9vb14ylOeopJPwuGwGkspeBqNhrIKuTgY/JbxFS6uZrOJQCCAer2uXud7dCVFLIeC6mQd06NkxwDGWiKRCAAoZVIsFtU4+Hw+VfMjYyZyzjC+EAgEMDw8bKrbY90MaUMGxund83yXGnpchJ5SOp1WtFQqlVJZfkwRp3dExToxMYFisYhsNovZ2VnlTcg6J84Pn8+Her2Onp6eeZl0jIkmEgll7EhPysrgWew5Q8VCg5cp8sxe5VbrNF6mpqYwOzurMvIqlQpmZ2dNyszj8aj7z9T7SCSiYk+cLxwnFgv39PSg2WyqGB3jvXaBo6Q0yEpsutjNZlNVdJNO4MJgLIVKSgpI0hX0DkiDcRF1oqdWGqRA7u3tRTwex8jICEZHR1UAnMFvegPlchmNRkMtvlKphKmpKbRaLZOwSCaTMAxDKTcZOOY9kp7siay/5TAE5Byg0AwGg6rOhUqKxaiksPhZOZ7yu6S3LeNQ8XgcoVAIqVQKsVhMKSnOW7bE8fv9qNfrHZX4Uo+JHBsab7IAl+uI1whAtfih55DP55HJZDA7O2uKzxCsZ+Tn9aQnObf4OzJ93apd0lLNGZmR5/V6VXyV3jdjic1mE7Ozs6o4mXQfjTsAKnbFEgwqPCodt9uNSqWCSqWifpvyiONDepAsEmsOu208O0pKgAKUNxk4NumZ9UKBSMrB7XYrV52LTcakmLkGHPcCQqGQoh8oSPSYzEoDExvC4TA2b96MNWvWYOvWrbj00ksVzSA9zlqthqmpKZRKJTz22GPYv3+/ojFarZaKS1QqFcTjcZWw4vV6TYYCrU69KJOQC0wXPEsBq1gU6bhEIqFqX/r6+hCNRk0CulKpqGxQeoa0ekkxU6ACUB5HKpVSXQlGR0dVJxTW7M3OzioKkX3bWCqhewlW47JYikxXvhSqXE/lchnAsTo4KqtWq4V8Po/p6WkUi0Xs3r0bc3NzyGazmJmZMfWgk7FLemUul0t1a2B7Iekpyd9naQiVlcwclGOzGHNHGluk+5rNJo4ePYpcLodMJqMMNoYGSPc1Gg31fiopOd8MwzAZPDIDlnVYMmuW6zYajapOFqT9gKVLHDkVOErqt5CTUqbrytRW+aDXxGcZ5KaXJLP2JJ0oa2ZWuhclaZxAIKDoG92DcrvdpngeFx3rnkqlkuLCGWOiYJaQ94i0q6TDrCzf5fKe+CyFBseF6cUM0vt8PlMmGb1zOd90QSm/X1KJFD6kU2XshcaB9Mq6DelBcQzkA8C8cWFGHz0EmdUn77s0FDn2skyEvy89KJlRqae36+e9mGPAZ2moSGUulVSpVFKUsGQPdCNMLzXQZZasISRkQpiMxdvFeD7rlRRvLMHsKpkYwfRPus3AcaEkW6oAUDyvrI+RE17P+NIzBO3gXp8seC3RaBSrVq1CKpXCBRdcgM2bN2NgYACRSETVi9XrdczMzGBmZgazs7N4+OGHkclkcPjwYUxOTirLkMFflgLIdjAUuKQ1pqam1PcVCgWTR7UctI1UTMD8ZqGMzfX29qrMNWbd0Rufm5tDpVLB2NiYKZ1YCkrOUTl3GCBnckk0GlW/w+slFU2vhfS1pEdPVCu1WGPGNUYjxe12q44hrJNjnNHn86nrpuKW1DrXDXCM6WDBqt/vV6UO8Xgco6OjWLNmjaq3YpISPbDZ2VnMzMyopJJSqTRPASwV3ScNLZk2z5hdJpNRCkwW6XIcZS2cTPaQNZucLzSQAKikGRotkn2QpRLhcFh5lzzXbsmls1pJyUGX1h1pP1rzVFy06GilcRExECnro3QPykpJSWvFDhbuqULG3tLpNHp7e7Fq1SqMjo6qGhcAilcvFAqYmprC5OQkdu/ejZmZGUxPT6s+YvQ8GCxmGi0pCi483h96YqVSSWUI6h7IcmUo6XEoUm6kUUj90ppvNpuoVCrIZrMol8tK0Vol4EjvTAogelKyni8ajZra3MikHKnAuyF0pNfA7DrDMFAul1XLMHpIvHZZR6ivHZlAIr1KGgTpdBrpdFoZPcDxzhSNRgPFYlG11OIcIt2vz5vFHivpzdFjZIYeaWxeL4B590y+JpWU9ILknJHzTmeApJLiGpShiG6XyZzVSkqCN0oW8Uk3vN1uo1gsqvfSEpE3WG4hQCtFVonTipSV4sB8BbUSvCnSmuwaMTw8jN7eXiQSCZUSzUWYz+eVt7Bnzx5lwZL7ZnEzaapUKoWBgQGk02llZVMwMwmAvP3k5KQKJOv9x5YjDsWxkAKByikUCiGRSCCZTCpLttVqqU74TABgckC5XFZCVH4v/5ZZjDJTjindjFORIuP3klpl/E4KneVQ4vI3uCYAqNhKPp9HOBxWGY2ywJsUF1kNNlClQcJ1RCXd29uLoaEhJBIJlfXIJIR2u418Pq/in2NjY6rWiNvq6HNnqRMn+CwTY3j/rJSNBM9VMjNce2xKy5ZTnB/8HT3BotVqKaaCJQw0zvlb8pyXE46SgvW+RLRma7WaopJo5TNYKbl/Jg/IrD0G9ymsGSTl91nFG1YCKDyZEcR0876+PtVvjZZuvV7H1NQUstksHnvsMfziF79APp/HoUOHTEKZ38ceievWrcPw8LDq1kGjoFwuY2pqCuPj4zhw4ADGx8cxOzurKFnpSQHLV/8jPSj2X2Mt0ODgoDoXJjPk83nMzc2pJqdMxZfUnu5JyW0ZmCTAVG62twkEAsoQKhaLyhjIZDJKGC+UGLBU4PczG41riAKRSQ6tVssUS6LAZtEtx4MxGyqWVCqFeDyOgYEBbNy4EYlEQm3tQW+gXq9jenoac3Nz2L9/Px577DEUCgU1f/RY4FKOi9XalzQjvSome5A+tpoXMkbJGjym2IfDYTUOBEMXjHnRWGBnDxoMzLiU49INA9pRUr+FfgNkLGChAC89Bjlh5ESiZS/T2RcKjK8UcGFQUdGS5aLSA8LlclnRKkw/lx0QmI4tN32TXSa4eLk3Vy6XUzSRrJNZTu9J/s3xoLDgtch0XsbmuJ8R639kwgTP30oY8W89IUP2eaMw5lizjRQ9El0ILyckxSUpJ5ndVyqVVNmGDPiTupTp0oZxrP4QgKo/ZOYsW1DR4GTSBWusSBNLT02nQJdyjGQcW46N/Fse4/zi/Zf/y7R1evCkfmWyDuWZNOb43TKeKnsHsh+pHltfTjhKSoOkJQAo693v96uiO9l4lhNEWr8yAaLdbqNarSKXy6lgOQWT3FuK4OfsSvlJaisSiSCVSimKpbe3V6X+SrppYmICMzMzmJycxOzsrLLmgeOp1LFYDENDQ4jH41izZg3Wrl2rOsy7XC7lfe7duxc//elPMTs7i7GxMeWBdEvpywXOTfoSiQT6+/uVwGTnh5mZGdRqNRw9ehTZbFYVpsrO3fp3AzAJIyrxnp4eDA4Ooq+vTyVkkEqcmprCrl27kMlk8Otf/1opdZlmLeM8yzHf+BvyPtHA4LgEg0EUCgXVMUGWb5Belq22mBTAVPxUKqVigKw/4+aG09PTKBQKePjhhzE2NoajR49ifHxczVMZi+L5LjWs1j2P6/KEykNu9MjkGRqJfr9fUeRUVCxcZmccGkvc8JE0NL0mn8+nUtFdLpdKJpFhkOWm/hwlJSCtG+lJyaacstCXx8gV614UwWwi1jXIwsFuZs2cLqyEBukmjgXrTxggZ4Ca3D/HWi925a6r3P+Glhw7D2SzWYyPjyshz6SMbnLmuiBh7QnHg9Y8PT8ZsKdy4nzg9/FapBLhmMtYlOwYz3EolUrIZDKYm5tTRaB6LVm3PCngeHyDwo9JAlxT9Ao4FvRQmUBD74meA+OYqVRKJdrIrhVMTMnlcjh69CiOHDmiujVwPduB1bDypAjp6VBJ8d6zDs/v95v23OJ2OMFgUIUf9FpCfh9lGQBV1CszLTu1iloOOErKAlJBdQqkSosCgApWyiaRFE6y1oPfR+Wne1LLacmdLug9ULnIPX6oTKQw5hbe7XZb9VAjhccU83Q6jfXr16tYAjsn0Ms4ePAgZmdnceDAAdUeR3pQwPKPme45U3nQ+zMMQyUqcPNLWYDM9F79uwgKBo4xYy5MVBkeHlZbwBiGgbm5OZRKJRw5cgQHDx5EoVBQ3Rr0HVi7Gf+UtB/HCDieeUaKlIkUFJZskUVqT3b45l5MpBGZ/VmpVDA9PY1du3Yhn89jbGwMMzMzKBaLpszBbq83XQboVB8pcc4xek2sRaSyZjYjY31ketxutzIaqewMw1DPjUZD7SzOlH4WEXOdyQ4XlGFW57/YcJSUBmm9yloSqbD0ie1yuRTVw0lBy1Cm3EqhKuNcdlkoJ4Kk+uQ2A7TEaLmyE4fMLCsWizAMQwXHaQ339fUhlUqhv78f55xzjhLEiURCjWGxWMS+fftw6NAh7NmzB2NjY4qmofXXjbHT69uYDk7LFTi+k3Aul1PZjKVSSVFvegowwXFm0JydO1atWqXaTo2MjCjvolarqTq0AwcOYN++fahUKmorCrnrrB4PAZZv/KQ3Jc9DJkjQi6pWq8pjJH3ndruRTCaxbt06lW7OuQRAtUqq1+uKXh4bG8MjjzyCYrGIsbEx1blBCly7rD1J9cnMPnqT3PyRW51wOw5m9dGbpEKj0ieazaYpJZ0UIpNQOCasWysWi4qWlan/krnQGajFhqOkOsBqIctUT7kFgCygk50k6C3ICSe7WCx1weBSwCo5hEpXUqHyurknUCwWU4KI1nMikUAikVABX1p/9ELJn5O6krVEdvE69bGQBg7PVSaKSPpOBqb172PSCMcuHo+r8ZLGgVSEmUxGNZXlfTgZSrlbMVA9mM+sNnnOsgZK7mArNx7VY2xMsybFKvfTktSqndaeVbjBivaTW8gDMMkX3bgGjhsEMlGH81GnVQGoOBVLGzweD0qlkvo93bBe6pCFo6QWgLRwZeYLm3pyt1laurSg9cwv2QaHKe16ttVKAS0zWSfGwlTZzogWWzgcxuDgIGKxGPr6+lS6K/shshN2PB5HT0+PGkNSDdPT05iZmcEjjzyiaqzoQXUzniez7WQHBNkln3U+FJY8Z0mX6rUv0nombbxq1Sr09/ejr68PW7duNSWZFItFjI+PI5/P4/HHH8fY2JjqdSc7TFARWnnt3UjWkb8j1wC9Pa4NJtVEIhH09/cjlUqphBFSX6QGpYHUaDSQzWYxMTGB6elp5cXKejo7rrtOoQWeK7cW4XVLhQtAsTVyCyFu/cIM21arpXrzSWOIuzJwxwZu+yK3EJmZmVGUKutHrcZzMcfWUVInAekZUWHJnT4Z6NX78cmqeOkqdzuA/UShx044USkUpdAjXWUYhho3tr8xDAPxeFx1Y6BVDBxPvCBlKHv86ZlYdoCVFUvPUs/ilJ6o3nFEn2NerxeRSER5UPQ6SelQCHGPpVwupzKyrIQHz1Oeix3GsRONLtPO2ZuQadWyeJ5p7dITkbHghdpl2RVW5ymVCmDuRMF1qBsAbF5Mr1IWVEvDSca+AKjGs9wCBDhWIsAYNL9DMkYO3bcMkBYyJ4RsZ8+ApNwFVS/ilW1raNXJXTHlTqB66xq7Qqf5uEhII0xPT6NcLqsO1AQ7BTABgJOdk1rWcXCyM35z9OhRPP7445ibm8PU1JRKlrCDgrKydhl/rFarinKTtBsFAJNHCCl4ZHkDW0utX78eIyMjiMfj6O/vVzUvpVIJs7OzOHTokKr/YUcF9p7UMx+tHnaAjL0wSUKWN7BomR3yZSyLNLqk/GgcRaNRlMtlxGIxeDweVaMHYEkF62JBV96M0dIIofxhWylpDFNR8/2k+wgyFo1GQ8W6pPwKBALo6elRa65cLis5V6lUMDk5qb5Pn1OLOa6OkloA0rKQwkPfo4YKRxZzSmqF9VWypxtvtvS+uplxdbKQ/LfMYJubm1ONQ2nVyr5qHBMpiGTbF77fMAxVE3XkyBHs2rUL2WxWZa7Z0QPl+VBJSWEoYy281wCUx6hTe9IIYt3ZunXrsHbtWtXJgokp7P03NjZmikfJAmedTraKIdjFq5BGIdv6UFFFIhFTZ33OPSbO6EpKNkplcTgAU+at3RUUYO0pcW4x+5HbCUkvkkqp2WyatvYgDU2ZRdqeiRf8X3bQITtSrVbVmDFblXOMzxKLNb6OkuoA3WuQD8A64CutVj0AysXH7LZarYZoNKqy/mSQk7DjApLnJCv5WXNCas+q6aXMOJKKRh9T+b2yK4DdrH/deiS95HK5TJ0MpKcl5w1wfCHrPdJoybLuh2noAFQ/xFwup7p4y958MmHCSiHZRSkB8z0o0nnxeBzJZFL1n2MMRsZDgONJAVyD7OhBYcxC10QiAa/Xq7abl5m2do1PSegeO41BGsO6suY1UqmRjpddPjgejOlJY5x/yy1fDMNQRcIsH+E94bxdimxbR0lZQFdQcp8VWhrsEExetlqtKsqKE4GKioFM4FjKNWs8Wq0WSqWSKm6VKcl2t/QM41jHACYMUKA2Gg1Eo1FT2iwFDGMK+lYLtGy52MrlstqBdWZmRtX62EmYSEFP2oj3kXNCZk4BMCki3l++TkXFsWA9EL2JdDqtfq9Wq+HQoUM4dOiQ8jbpVVFJ6VssyPO1GsPlHle5xigYuSFkJBLByMiIqgNjkgSVNLMZGW+RbcaoqJh0kUwm1ZiSBgWgvHIK1W4Wg1tBZ1VkyQrpSioH2bFE7jklM2mtEo1YO5XNZhGPx5UMo5eVTCbR19en5mIoFFLjTEVVLpcxPj6uWATZpEAa3E8EjpI6SUhLRgbFm81jW3Tzb712RhdADHiz151hGIqCIE1mV+iCjguE1isAE7Up98siRcpr1IPjMnjLCc+FpitvO4ICkjy/3G5EGjzS6gTMSSiSIna5XKZCVo/n2CaajHOxpVI+n1cBcdkbUt4jnp/+LL39bkJ6UjLNnF6VpKFkkg7jLbrHqqevBwIBRffxu0nLAvaKTcn5cCJZoMdCJaXHdclUfJ0mp0xiH0lShrLjvNwyhuPPchJm/wFQxvlSdaVwlFQHyDgD6Thu0sb2PvSG2EaEFrBsbsmHDIZLZZXP55HP5wEct+7kgrPL4gGOW/y0PqmYXC6X6rDtch3rdShryZieTiVOoSHT+nm99ET1+hY7eVESFJpSgNJo0TP39MUrlZOMUbJzdyqVQk9Pj9o2gVtMFAoFPP7449izZ4+K10kKy8pDAOYro26Np0xK4nzg5o3Dw8MqQYTdE2QH/Ha7rbI9q9UqpqamVCyUwpRrK5VKqZ523EK9VqshmUxiYmJCKX2rzQ67NS7637wumXBFpU2KWTat5g7GVkoKwDwlVSwW1TiwyJ5bywSDQbX7A0tDuLFksViE2+1W2beZTEbRiIs9fouupFqtFm6++WZ84QtfwMTEBIaHh3H11Vfjz//8z02W20033YRPf/rTyGazeOYzn4lPfOIT2LRp02KfzmlB3khaKaQLJLUg658kl8sJQKtOcruRSMTUK4utXRgMpXUnvTA7KSrA3HuNwoa8tz4e9ABI15DuA8w1V1Khy75/MpXabuC9occklSwVl/5+wLqrOYuYSaO43cd2PI7H48oDZRZlLpfD+Pg4xsbGVLdzGRNdyIOS6IbXrl+3bK/FhsUy1Z5WOmlO1j9NTk6qFlA0imggssEsWya5XC4V/83lcmrLndnZWXg8HpMRZCfDUI6VNPrkzgD6Q1KCVF6d6jHb7bZpKyHKNNKjTLyQCV+MF4ZCIRQKBZWtKlmSxfamFl1JfeQjH8EnPvEJfO5zn8N5552H//f//h/e8IY3IJFI4J3vfCcA4KMf/Sg+/vGP43Of+xzWrVuHD37wg9i2bRt27Nihqp27DakcaIUwKM4F1mw2lRclY1a8sfJmcbHJJpHct4XZR6TKAJiEnF0UlZ4osBAFyte4oJrNprJkmeknA7WyxoPtfKi4u91AdiFYLXwrj0m+TwofvkbFFAgE1JYTTJYgrTU3N4fDhw+rzRIZY5E1QFaeU6cx69a80hVVMBhELBZTD3YfkWUJjUZD1YBNTk4q5cQ0aBn/ZJeOUqmkjEKyG+l0Wnn3zBiloJbCuluwMmAkFUq6jXICgNotnN40QW9ej4VKSMqQcou/TTnFeDOLfGlcBwIB1Go19R69Vm2xsOhK6sc//jFe/vKX44orrgAArF27Fv/0T/+En/3sZwCODcpdd92FP//zP8fLX/5yAMA//uM/YmBgAP/6r/+K173udfO+k1Y1QXpsKSAXrrx57XZbcbaMC8j6H1ovsg6GAUhmxJDW4Q2lIkqlUiqbLZ/Pz+uzRnQzhqCPCwCTcpKb2XFh8ProIXKhyTgVJ7sUDtxmnpSObMxrR8hEF+JkFqr0JpiSHw6HMTAwgN7eXlW0y47phw8fxq9+9SvMzc3hyJEjmJubM3n6cnxOdqy6NabSYGM3Ej6YMBKJRNS6qlaraoPLQ4cOYe/evajVamq9yNT1ZrOpMvqCwSASiQR6enoUddbb26syMKn4OH40lLox33QFJZkGtsaiJyObBzBGSYOOioYyU1KDMk1cUtRMApMxdJltKRs+kxplpjLT/BmT1ePxTxTuE7/l1PCMZzwDDzzwAHbt2gUA+NWvfoX/+7//w0te8hIAwP79+zExMYHLL79cfSaRSOCSSy7Bgw8+aPmdd9xxh6nifmRkZLFPe0HoHoOsDZDutaxul+62nrEHmLeblwpNWj6AfXfrlZ6U/F9PuZYPOX5SQMuEApk+q/ees6uSIqzGY6EH30dhJGkvaS1TCMmu8owhWAXE7TpOekKR9BJkzSEpJwo5ri25aSZjlrIXnWykq7eEkgyG7P/H+BXnYDfHptPfcp3I8eK1yDIFeludHgxRyC45MhNX76bTqT8pP6ff06UYw0X3pD7wgQ8gn89jy5YtKmPt9ttvxx/+4R8CACYmJgAAAwMDps8NDAyo13TccMMNuP7669X/+Xx+SRWV9Bp0fl+nuehZlctllSABQHUWpoUsC95ozVAwxWIxtVeS3L9FZnrZSfBIZauPk/Q82+22aVJLSo/XzoVAxVQul1XqOTeK1LuF2x0nOk+5kGmxDgwMIB6PY/369TjnnHMUbVWr1XD48GHs27cPExMTqos3LWdd6dkVVhQWm8SybyPjUYxbkr1gL8IjR45gamoKU1NTyOVypuQAzrVaraa6L5CBMQxDFavSayd96vP5cOjQIVUArWeeLte4ynUux0h/kA5m8hEpN3Y4CQaDqtN+oVAwGYY0oqX3TbCjfDAYxMDAANLpNHp6etRvkO7jebAOjefMNS+zWBeL+Vl0JfXP//zP+OIXv4j7778f5513Hn75y1/iuuuuw/DwMK666qrT+k5aAcsJXVHxmJWiomDmgiD1RY/IKkWWr8suA7K10mK7zIsBndLSX+OzlbLia3zoXhQAE7VDK1l6C2cKdAqXCRPJZBLJZBLpdNpk3OTzeUxOTqqaMX231JU2NhRkVt3NZfyIa4lClwXMci8xq151OpMBQHkfVH4sAWGWLr0pnl+3YeWhUF7Qg4pEIgiHwyqrltcsvSSppOR2Qaw75INNsuXW84wLSo9Kxk/1mCrlg+0TJ973vvfhAx/4gIotXXDBBTh48CDuuOMOXHXVVRgcHAQATE5OYmhoSH1ucnISF1544WKfzmlD54YBcz0HG1zqPf1YwEkBIieXDGCSJtS3DtAFt45uC6ROSRNSMUkvkGAard4tXnqklUpFpffTsrVjG6QnCs4p9kuLx+PYsGEDhoaGsHr1akSjUbRaLWQyGVQqFRw9ehSHDx9WmyZK4bvSxkUXuLJ9kRSKXCsUqBSqwPF1KIWkjN1wI00WQcdiMWUAynOQlr5ujHYDOmsiz4vGjO5V0cNhTIjb4ZCZIH1Or5Tzh93QGZ5grEvuU8WYnqxRo9eWz+cxNzenavVkh/nFNioXXUmVy2VTTAWA0ugAsG7dOgwODuKBBx5QSimfz+OnP/0p3va2ty326ZwWpILis5wktP7IcUtrUE8ukAFiqcA4QSiI+X6d77UrrBSUy+Wal3otvS9uDEk6RwZuZcyBcQcuspVE9Z0MOJ8CgQCSySR6e3tx7rnnYt26dUo4FAoFzMzMIJPJ4MCBA9izZ48ao5WsuKWSkp4U5wXjJrznNF4oXDmfmBFKj4vKjY1oY7EYent70dfXh2QyOW9Let0TsKJNuzG+nWK8egyb9WCsN2SYQV8rTDNnJxdmzLIIulQqqVoojj87fdC7peFsGIZKNpmbm8P09DQymQyy2ayiGzt1m38iWHQl9dKXvhS333471qxZg/POOw+/+MUv8LGPfQxvfOMbARybINdddx1uu+02bNq0SaWgDw8P4xWveMVin84Thq6oqKykFyW9KbkIrQKU0lPqFE+wuwBaiPaTVi7HgAFdGayWzVYBmJS2HQorlwqcP8zkS6VSquhU7o3EGOXc3JxpE8OVEoM6FXSitughsd1WOByeV6hKj5I0IZOrmMpOwSsTMSQlSIpMpw27iYVCClZeChWYlXHNOk1m3nF+seDc5/OhWq2qcdZDDzwfGozlclnFRJnEo+/RtdjjuOhK6u6778YHP/hBvP3tb8fU1BSGh4fx1re+FR/60IfUe97//vejVCrhLW95C7LZLJ71rGfh29/+tu1qpAiZWUPviSmZqVRKVbTTk6ISolXIxSJpQr1hqm45dVJedoHVuQNQ3LaskO/v70c4HMbq1auxevVqpbS4sFi8m8lklFAm3XcmCWTOC2ZgjYyM4OKLL0YqlcLq1auRSqVQr9cxMzODyclJPPLII5iYmMChQ4dQKpWUsFqp49GJyuJr8sEYUTKZVF5Au91GJpNRHQ6kkopGo6oYeOPGjYhGo1i1ahV6enqU4CX1Va1W1W7PnG/lcrnr803SfZJtMQxD7RnGruR6mIDxNhlyoAyjTJExKSp5MhaSgk0kEsqDItMxOzuLarWKyclJTExMIJPJYP/+/cqrore2FCn8i66kYrEY7rrrLtx1110d3+NyuXDLLbfglltuWeyfX3ScjCcl0z5lyqie7ilTOHVPaiHltFLAsaFXyUA4g9R8MFAtYwJUVNVq1dZdJk4XMq7JeRONRtHb26v2SKJVW6lUVPbZzMyMbTd6PF3oisoKcg2xxjAej5soPqmkuHkmE08ikYjaTJOeK+cZ09Vl13ir+dbNpCUrL4retN4KiecoKVSrBAbKLSoeeln6HlMyJkjFTiqebdzy+bzyqKigVowndaZBj73oVoJcTKRreJOpvEh1yTgMd51lEJJZW3rKtV2FklTGsv6kt7cX6XQa4XAY8XgcgUAAfX19CIVC6OvrU+39ZfYag+P0pGSnCbte/6mC3oHP51OKaXBwUAnURqOBQqGAo0ePqlTryclJlTxxJilsACbhWyqVkMlk4PF4VGEtxwo4JlzZWb9SqagEG+C4wmNCTjgcVhtDMl7TarVQKBRQr9cxPT2NfD6P8fFxHD16FLlcTs033UvtVkxKxrQpC7LZLIDjMf9wOIxSqaT6GyaTSdVXj015pdFMxoK/IVsmyea0wLEeoiwLYdLK4cOHUSgU1Brl3/TEdCVl68SJMwVWAUy9sJQBTXoP7DTBmIsMBDOjjZOOBZqFQkE9SHFJfteO0GteeM2hUAg9PT0YGBhALBZDOp1Wu3uyYj4ej6vvkYuFWwZks1nV2WMlJwhIyHHy+/1Ip9MYHBxEf3+/Ei5sfTQ5OYndu3erwHQ2mz1jlLW+pqSSymaz8Pv9SghHo1FTxh7TxmnUsEM3BbBkLPSYJ9datVrFzMwMstksJiYmMDExoag+vW6om+B5SI8nn8+r62BTa/4fiURQKpVUI2J2gKDXSepUjr+uoNjthgaC2+1WnlOpVMK+ffvU3xxLuTWMXKuOJ7XMoIKiJUKqgDxuvV5XMSZmuOlcO4UxABVkZB87Ulwy5Vq/4XZZPJ2gNwmNxWJIJBKmRp9UYuTLKXi5saGkEOzeBulUICli2SWA6dYAlGfdbDaRy+VUWu9KK2I+GVgJSm6aGQ6HlaAkLUwhCxzfe6zdbquxI2RyEtcbBXy5XFbGDzeJzGazqtxBZy3sMN5SUQFQdJ/b7UY+n0etVlMJJaFQCMViEX6/H6VSSW1zIvd1k9mMrdbxfbhk1w7GPancmSRRqVSQyWRM3T6kclrqUIWjpDpAnyQUqKwDYsU894SS+6yQpmAgVC4YFiJmMhnkcjlTAJfbpssCWP18ugnJcUvOmzRDIpHA8PAwRkZGkE6nMTQ0pNKC5Xbp0oKbnZ3F5OQkDh48iAMHDiCTyaBQKKz47D7d22S3+3A4jHQ6rbZENwxDJUuUSiUcPHgQe/bsUcLgTPGiJGQMstVqYXZ2VinqcDiMWCwGAMpjIG0n+z7KQnk5PmQpWq2WovKYzl8qlfDYY49henoak5OTmJycNNUT8dzkczcgf1u2E2MJArfJGB8fV5l4NABJsetKiuuUqfuydopGIWWUNKQ5B2k8yp3EmdRhJa8WE46SOklYBTGZzil7hgHHO5hTGMvPsuZD7pcke/7pVslK8KRkDZnMdKS3wEw+mY0kC3gZm+OYnEmCWS9JYFIJU3wpsBlnYZ0Yg9Er4f6fKqQByEwzXn+xWAQA1cHcMI5vCqp3hLBKPKLyI31KSj2bzaJUKiGXy6mmslxzdlBMVtCVL41eejtcP16vV21XUqvV1BoslUqmkhfOPXqarKGSPTLlMd4XKizZXFtP9tLPdzHhKKmTAAefQqNWq6nWNFNTU6Z+WdzYUPam40JkAJdJApOTk2qPIKbALiW3u9iQsYVqtapS8CX1AhwfN1pi7MdWLpexa9cu7NmzBxMTE5iamlJ890r2ogiZCcpCZray4a6mvF5uwcE4iVUgfyVDKiYmzPAaC4WCCtyzRc/c3BwSiYRKK6e3wLiTLmzJVtTrdRQKBTQaDZVeXiwWVQo155j0IORcs9t4y/OSKeWk7WgAMZZXKBRM2cfA8bgdvSopX6zoOo6pbAxt1XtU9z6XCo6SOgE4OfSMG1q62WzWtPWG3+9XxXG0Yth/jAuSdB/pBn6XnAB2XTRWIH1AT1JSMrT8qNxJY2UyGRSLRYyNjWHfvn0qTiAtuzMBFBj0KJnxycJvehAzMzOm7Umk13mmQXoCHAMqKRaYFgoFRKNRlabPjgjSG5VClnEVGoD1el3NsVKphNnZWdUOiPOLcWLA3uvsZGRBp+J6qwLfhX7jRL/TDbnkKKkFIBUUYHa5KXzZEZiC2uv1KmsGOB6DkY0d2ZZENlC1szVHyPPjIqeQ4R5fExMTCIVCKJfLypPgGDIpgDuqsrP17Oys8h7OBA9Kh7SAOQdKpZJKxbdqBXWmjQEh15S03Pl3sVhUjUyLxSJCoRDy+bypUJWKHzjupcstc9jyh14qk5NkbHi5vIDlgn4dkhJd6H0n812n+vpiw1FSJ4AV7UaF5Ha7Ua1W4Xa7kc1mVYEqaS4ZVNRb2sjuASupkFd6lLLvINNkd+zYgUwmg8HBQRQKBdM2JePj4xgfH0ehUFBdFNj/SwawzyQPQiabkOKiEUP6hZY+d4o9U2NRhKTPgeO0EbP89N56XE8LdSmX46XXM8o5eyaPq8TpKCe7wlFSpwC5CKSHJRulSqEkg5ELFQqutIWje1SMubndbuRyOdUrja1VaL1yLyAWbzJRQC8GPBMh4yZMnKEAlgk0K7W7+ROB3RkEB92Fo6ROAQsFMclv61beQh7SyfLAdoVUwuT7f/Ob32Dv3r2q+l9SO6wH07cKkBmQZxp4XYxDer1eVCoVBINB9Ro7ITB55kwcBwcOTheOkjpNONafmbahB1CpVAB0pmTONsi4CzOwGo2GyvpkEbjM6OPnHDhw4CgpB0sER8geL1oFYEoZbjab83ZNXcqtDhw4WMlwlJQDB0sAUsKMQ0nP8kSBfwcOHBzHGaOkotEoNm7caJs9qbqNdevWzRuLSCSCjRs3qiK/sx3r169HKBQyHYtEItiwYcO83aUXQqfak9N5n92ysjZs2KAKj4lwOIz169c7sbPfYt26dYhEIqZjoVAI69evV7WDZztGR0fnjdHJwmV0exWcBvL5PBKJBHK5nOqqnclksGfPHlSr1S6fnT1Apc0+aMCxMdq7d6+KG53toNKWndmz2Sz27NnjjNFvEQ6HsXHjRiQSCXUsl8up/oIOjimkjRs3IplMqmP5fB579uxBqVTq3onZCKFQCBs2bEAqlVLHrOS4Fc4YJeXAgQMHDlYOTlaOnzyn4cCBAwcOHCwzHCXlwIEDBw5sizMmcYLxFicmdQzRaBQbNmwwxaSy2awTkxJgkoSkGhhvccboGMLhMDZs2GCKSTHe4sSkjoExKTlGhULBiUkJMCYl43YnizNGSe3YsQO33HILxsbGun0qtsCWLVtw88034/zzz1fHHnvsMdx66604dOhQF8/MPti0aRNuuukmXHjhherYrl27sH37dhw4cKBr52UnrF+/HjfddBMuuugidWzPnj3Yvn079u7d28Uzsw/Wrl2Lm266CRdffLE6tm/fPtx6663YtWtXF8/MPlizZg0++MEP4tJLLz3lz54xSqpYLGL37t3Yv39/t0/FFvD7/fO8gVKphN27d2PPnj1dOit7gX3zJEqlEvbs2YOdO3d26azsBW6/LlEul7F371785je/6dJZ2QuNRmOex1SpVJwxEuAefKcDJyblwIEDBw5sC0dJOXDgwIED28JRUg4cOHDgwLZwlJQDBw4cOLAtHCXlwIEDBw5sizMmu8+BAwcOJBZq6LsCu8GdtXCUlAMHDs4onEy3+U7vcZSX/eAoKQcOzkCczrYgZwL06z7ZbVT098uxORPHaSXBUVIOHNgUpypgO33OSvBKnAlC2GqsFtpo0uVyzTtmtfEkN688E8ZopcJRUksAOfnPpMl9ukJT//zpjMmZNI46dGHKDRd5fKFxP9E9sfII+Mzt6leyED6RItL/PtEOycRKHY+ThRyPhYwaOWe6NSaOknqC0G92JwuNz3a46acCeU1ut9v0DMwXfBI8Jt9PgciHlUK3EqytVmvB31pJ6DRnXC4XfD4f/H4/3G73vIf+Hbrg1cfNMAzU63WljAzDQLvdVmPZbDbV39xldyWMra5o9Dlp9X6OnxxHfT7JeUmsNEV+IoOGD4/HA5fLBa/XC6/Xa/meZrOJRqOBdrutnrsxBo6SOk3ogkYKkoUWgi4w5Gt2g66g+OAEJ+TC1q0wKUDkZ1qtlul3rASs1eNM27JcFxo+nw+BQAButxter1e95vF45n2mk5KSY+VyudBut00P/Ri/w67zsBN0Ba8rcvk+OQfltXaaU3zPE/H+lxOdvG4rg0jOLb/fr/7m+zhW9XodhmGg1Wqh2Wyq15d7LBwldQrgjfR6vfD7/fD7/ejr60MoFEJPTw96enpME4ALoNlsolKpoNVqoVAooFqtolgsIpvNquaUjUbDNkJYKiSfzwe3241wOIxwOAy/349EIqEsfp/PB4/HA5/Pp4SfYRgmYevxeOB2u9FqtZTlzmcunFarpax+WviNRgOVSgWNRgOZTAb/f3vfGhzndZ737P1+B7ALgAQISaRJWY6siJGsODO1R5zasieOLbcZeVhFI2escSrZVpRxFDdV3cRxFdtJY8vNSGl+1O1UbtrMRG7sGTvDWqoUz8iyRFp1LIkXSeANBLAL7P2+i/36g34O3u/gAwmSIHYX/J6ZHQB7w/nOd857fd73tFotNBoN1Ot1k0cwLNAFhsvlgtvthtPpRCAQgMfjQSQSQTQahcfjQSgUgtvtRigUQiAQMH0H5whYVUrSQ2q32+h2u6jVauh2u6ZHrVbDysqKahyrW8jy9ysN8W4W5DikwpHKnfuO7+V8cC2vl4NaWVkxGYx8Djg/z/qeHIQ1p3tF3IfhcBherxehUAiRSAQulwuBQAButxt+vx9+v9+0Jz0eDzweD4Dz82oYBhqNBrrdLnK5HM6ePYtms4lsNotms6n28FbCVlKXAC5yr9eLYDCISCSCPXv2IJVKYc+ePdizZ49aDBS8KysraDQaKBaLaLVaOHfuHEqlEhYXFzE7O4tGo6GEhNws/QQXr8vlgt/vh9vtRiqVQjKZRDgcxo4dO+D3+xGJRBAMBuHz+RAOh+F0OtWmDoVCiMfjJkXXbrfRarWUIpICpN1uo1qtotvtotVqodPpoFqtolAooNFo4NSpUyiVSigUCmvCVIMgNC4GK4vW5XIpSzYej8Pn82FkZARjY2Pw+XxIpVLw+/1IJpOIx+MmL6DRaCilzrnodDpYWVlBs9lEvV5Hu91GsVhEu91Wj1arBbfbrcI3/DzncRC9e6uohQxXORwOJYClkqJSpidq5UFx3nQlRYFt9f5+e51y/TidTni9XgQCAXi9XoyPjyMSiWB0dBSTk5Pw+XxIJpPw+XyIx+OIxWLrelIulwsrKytYWlpSpwEcOXIEpVIJ9XpdeVNbvedsJbVByLBLNBpFOp1GNBrFjh07kEwmMTIygkgkArfbrbwKbhIqLJ/Ph2azCY/Hg263i2KxCK/Xi3K5rDwJaR334xq58X0+HzwejxKemUwGY2NjCIfDmJychN/vVxa+x+NRlj4teHpeetjK7XabhCHntNPpIBAIYGVlBa1WC91uF+FwGH6/H/V6HY1GAx6PBysrK6hWq0ogD1OeisJTeql+vx8+nw+xWAyhUAgjIyMYHR1VyomvRSIRk5Lyer1rlBQVf6PRgM/nQ7vdBnD+nnAOKZgMw1BCTs8NDgr0EBa9IeZRKKCdTqeaR643YNXblM/JUCgfTqfTFIaXBqMepud39AtSUXOPRiIRjI2Nwe/3Y3JyEpFIBKlUCmNjY/B6vcozj0ajypiUnhR/Z7Sj2+3C6/UikUggmUwCAHw+H9xud1+M6EtWUi+88AK+9rWv4fDhw5ifn8czzzyDj370o+p1wzDwxS9+EX/913+NYrGI9773vXjyySexe/du9Z58Po/PfOYz+O53vwun04mPf/zj+MY3voFwOLwpF7XZ4KKg17B3717ccccdiMfjeMc73oF4PA6/368ENRc6PYJAIIBoNIper4fR0VG0223Mzc0hGAyiVCop66VcLitPpB8bgQs1GAwikUggHA5j9+7diMViuP7663H99dcjGAwqS59WmNzUlUpFWesMI3A+ZMhKChmv16veB0ApoFarhXq9jnq9jkwmg+XlZRw9ehTtdlt5oNJjld8xKLDyoLxerzJ2RkZGEAqFcMMNNyAej2N8fFxZwBQuDGUBq/lOri2rEHGz2USj0UCr1cLy8jJarRby+TwKhQJqtRra7TY8Hg+azSY6nY6abwrtfnsLVp6TXDM+n0+FsILBoDKqKEhpHHEv0TgCoK6TpIBut6s8eOlN0rtqNpvKaKJR0K/9Kb1It9uNZDKJaDSK6667Du95z3sQjUYxNTWFWCym5kjm6mRIVM4p852857FYDJ1OR3nc2WwWc3NzqNfriowDbN1eu2QlVavVcPPNN+OTn/wk7r777jWvf/WrX8UTTzyB//pf/ytmZmbw2GOP4QMf+ABef/11+P1+AMDBgwcxPz+PQ4cOodPp4P7778cDDzyAb3/721d+RVcJ3BwU4OPj44jH4xgbG0M0GlUbSy5wCk/phYVCIfj9flSrVaW4aAVyI+nJ3a2C7knxWpPJJNLpNCYmJhAIBDA6OqoWvMvlMuVAKDjl+K1yA5wPChfdAuY8BoNB1Ot1pFIpGIaBaDQKn8+HlZUVFcIZRC8AWL82h9fKsHEoFEIsFkMymUQymUQqlVIWssyz8LOcS+kdAFgjjOhteTwelcuj8OH8y3syCHOpe096iI8hUnoRwWBQ5Uf5CIVCal1SSVEQU0l1Oh2lfJj/tCKXyNCyTlbZyv0p/y8NQK6bkZER7Ny5E7FYDDt37kQ8HjdFLfTxy3vOtSAJIvSomB+t1+vK4+rH+rhkJXXXXXfhrrvusnzNMAx8/etfx7/9t/8Wv/EbvwEA+G//7b8hnU7jO9/5Du655x688cYb+MEPfoCXX34Z+/fvBwB885vfxIc+9CH82Z/9GSYmJq7gcjYf3BTBYBC33HILJicnccMNN2BmZgY+n08l9ZeWlpDL5dBoNJDL5ZTQXllZgdfrRTgchsfjwcjICMLhMBqNBkKhkFoMjUYDjUZDhR62GlIQ+P1+xONxpFIpXH/99chkMti5c6cKH1AIECsrKyiXy6jX6zhx4gRyuRxqtRrK5bLJ8uTG8Xg8aj7S6TRSqRRCoRDS6bTaDC6XC4ZhwOfzwTAMpFIpuN1uzM/PIxqNwul0qu/XadaDAKtQlSShMP80PT2NaDSK66+/HqlUSoX2KETWY+FRwPJ7dQEk/zcAJYglSwsYnALf9UJ7Mm9HDyEajSIWi5lCWVIxc33oOV6Zf2LertfrodVqqTCXzOt1u12Uy2XUajX1Hj0MuFXgfY1EItixYwfC4TD279+P66+/HmNjY9izZw/8fj/C4TB8Pp/JSGZ4XObofD6f8uaDwaAiX/AeUG5xPwLo2x7b1JzU7OwsFhYWcODAAfVcLBbD7bffjhdffBH33HMPXnzxRcTjcaWgAODAgQNwOp146aWX8LGPfWzN97ZaLbRaLfV3uVzezGFfEAxJhcNh7Nu3DzfeeCMymQx27NiBXq+HYrGIZrOJkydP4vjx4ygWi3jrrbeUawwAwWAQqVQKwWAQ+/btQyaTUeGvlZUVhEIhhEIhlEolU46gXxvB5/MhEokgkUhgamoKO3bswOjoKFKplBIaMpzCjVAqlfDWW2/h1KlTWFpawtmzZ1WehIw/sv4SiQT8fj+uv/567NixA6lUCuFwGIFAAIFAQG0MzkE8HlcEg1AohF6vB6/XqwyBflJk14O0vOn50AgIBAJIJBKYnJxEPB7H1NQUUqmU8gaYY+K18fpkKLnb7a7JKfB33eKl98Cw6Hpeno6tmEurkKi09Bla5r1PJpMYHR1Vz0mvnuxT6UnJvB2Nx0ajgUqlYjKiSCzpdrvK65RjJBtyqw1JaUCGQiFMTU1hZGQEv/qrv4pbbrlFpRMk2YPhYBKQGAJuNpuKMUoP1O/3m8glvEZpMAJr6zy3CpuqpBYWFgAA6XTa9Hw6nVavLSwsYGxszDyIX8RX+R4djz/+OP7oj/5oM4d6UfBmBQIBjIyMIJlMIpFIqE3RarXQbDYV62x2dhZnzpxR1HKpVGnxNptN5PN5Fa4IBAKmMIZeT7SVAlcyhvx+P2KxmErmk3oux0irtN1uY2lpCUePHkWxWMTs7KxiMBaLRZP1xYS3x+NBu91W1hzDeQ6HQ5EHSJ9lyIKWns/nUx4oPdlOp6M2KEM1/U5u63/LXILP54Pf70cwGEQ4HFY5FGnp09onoYbKnsKRVrIkQTAEWq1WUS6XFWOy2WyiVqsp8gTzVXouyspDuNrhHV1BUVByT9A7IJEkEokgHo8jHo+bIhR8vyRVSE8UgFobOjuO4L0hgUmGw/i+foXgGX4fGRnBzMyMMhrJ6uOaZ8lGsVjE0tISGo0GFhcXlYJqNpvwer2IRCIqzM5ohc/nM93vbrercnI6UWkrMRTsvi984Qt45JFH1N/lchk7d+68qv+TiyMej+PGG2/EyMgIbrjhBkxNTaHVaqlF8Pzzz+Ps2bNYWFjA/Py8SvjLDeF2u5HP5+H3++H1elGr1TA2Nobp6WllBUqLuF+eFMdBDyqdTpvCcTKs1Ov1VEjv6NGjeOaZZ7C0tIQzZ86gWCyq8BKwurGlgKAgOXHihKozO3bsGKLRKG666SblYdCgIbU/FoupsOPS0pIS3NJqHgQavxS+9KLoEUSjUUSjUaRSKaTTaVUPxbVDxVQoFEz0cV4nALVeKLz4O8Og+XxefUer1UI2m0Uul1OGUrvdViQKWb+2leEcq7wTQ6LM0UajUYyOjiIYDOK6665DPB5HNBpVeRdZi6d73/z+TqejQlgsUGWEBIDK+3EvMgrSbDZRqVRM5AJ9/Fd7rjgviUQCo6Oj2Lt3L+68806VI47H4+q9nU4H+Xwe1WoVx48fxz/90z+hUqng5MmTKuRH45DlJGTiRqNRhEIhkzJuNpsoFAooFAqo1+sqBLrV2FQllclkAACLi4sYHx9Xzy8uLuLd7363ek82mzV9rtvtIp/Pq8/rYHJ9KyFpnvQqqGRYVFqr1VQ+qlAooFKpmAoBpUDnzac1Q+/KypPqF6SFybATLVNJUpCWfq1WQ6lUUjm5UqmEarVqGRqQ18ZrZfzf4XBgeXkZnU4HlUoFjUYDwWBQCRRayawJYdjCqpvFxfItWwk9hCXzcny4XC4VjiMJhQxGhqB0JcX6NQpXGkX02FknVa/XldfP79UZfVutnDgv+hzJInLOESMOLGkIBoOKaETvWn5OZztKEpKknvNv/d7IeyK/tx+kEjk2Gd1IJBIqXE4PmgqoXC6jWCxieXkZi4uLqFQqyGazqmFAp9NRBLZOp4Nms7nGsOPcSE9KZ39uJTZVSc3MzCCTyeCHP/yhUkrlchkvvfQSfud3fgcAcMcdd6BYLOLw4cO49dZbAQDPPvsser0ebr/99s0czmWDG9/j8SCVSuEd73iH8iY6nQ5yuRxOnDiBbDaL06dPY35+HvV63WSNAjBtgm63q6zlXq+n4sK0FlutlqLTcoFwLFu1KJj/sCro5OJksW2r1cKxY8fw1ltv4dixY5ifn0epVFKLXv+81fc5HA7lbdVqNSwtLaHVaqFUKqFWqyl2Gx+9Xg+ZTAalUgmBQABvv/02arWaUlZy3vtNn+bvUgBS8VPoejweZeVzHqQiITWaoRr5nWSFkiDAPIRhGMjlcpifn0ez2cTS0hKazSbK5TIqlYryoCRJYKsVlVWIjwqCyjcSiSgm6fT0NAKBAJLJJEKhkCksJSnjkknLPUfviV0UGA6j4nY4HOp/ckz8nPw+uQb1CMHVnCeumd27d2P//v3YuXMn0um06vrCLjbZbBbFYhEvvPACTp48iYWFBZw5cwatVgvlclmxbhlSJnmHOTx64wBUDq9UKuHUqVPI5XImmv5W45KVVLVaxZtvvqn+np2dxauvvopkMompqSk8/PDD+JM/+RPs3r1bUdAnJiZULdW+ffvwwQ9+EJ/61Kfw1FNPodPp4KGHHsI999wzUMw+bppIJIKJiQkkEgl4vV61KObm5rC0tITl5WUV3tLbhUgLTg+p0EtzOByKLCCtwq2GtDKtrCq+LuuX5ufnceLECZw+fRrFYlEt5I1sXklPB6BCKwCUUJaFmNxApNzKnBbnbBDCfITuHUhBJ5vIUujRyGm32+ra2UqrVqsp5qesL5NGD8MzXJ/s1MG8BOeUAloaJP1QUHKO5NzwuiQ1f2RkxMRck73mCHqgnBsqfnoYVFKMYpBIID0wjkHOqcxd6eSCrZgrzkkmk8E73vEOjI2NKaUCQOWhGMn42c9+htdffx3lchmFQsGyu4vT6VSGEOeasogyq9frqe/N5/Mmb2qrcclK6pVXXsH73/9+9TdzRffddx++9a1v4fd///dRq9XwwAMPoFgs4td+7dfwgx/8QLmYAPD000/joYcewp133qmKeZ944olNuJzNAS2YQCCgYt60sCigS6XSGgvlQt8naxvIUlovIdsvL4CLk9ZXIBBQsWgKXAo5hqEo+C51zHrOhp4G2y2xmJg0WIJKUlL8+0kNvhisFJVUUu12W3XckCE/GV6ROTz+5Hv5/YZhqBBfPp9XrFPSp2XYRrIy+xHu0xW4rHOih0kqfjQaVWF2AGp9Ss8SMLdAkt45vX56j1RSUqkxytFqteD3+00hVoZOuc43aoRtBth3j8o6lUqZWHxUNIuLi3jttdeQy+WwuLiIcrmsDByr++v1epFOpzEyMqJo/VT8VE71et2UymAurx+4ZCX1vve976IC+Y//+I/xx3/8x+u+J5lMDnThLr0bKhPeQLJcCoUCFhYWFIvvQsJRJoTZjy2TySh2Ej2JCzGstgoUXLVaDdlsFk6nE6VSCeFw2FSpT8u+Wq2iVquh2Wwqq5PXvJFr0AUV2W7sO5ZIJBQdXf5//l8KElrMg1grZaWcGO5j/oi5OdZ8MXRFZULvQNZEUZhIz6tQKKDZbCKXy+HcuXOmkKFU6rJThR6avVCI9krngj918gzzTqzP8/l8SKfTSCQSiMViiEajqm6ORlKj0VARCnnPJVuNJIJWq4VqtWqqf+J4+H5ZWC7fV6lU1D7fSm+C88PrHx8fx86dO1XExTAM1Go1RZI4dOgQlpeXMTs7qyI7VrLEMAwEg0HccMMNGB8fRzqdRjAYNIWRi8UiisUizp07p0gX7PDSDwwFu68fsNpUupuvv2b1ui6kuCEpdCQRoV9JbMAc1mNndiqDWq2mPB3mMmQBLWDunL4RduKFyASStCEp7/QeSD6RgnfQlJMUgpIeLa9Vtqjh2KmQgdW8nZxThpskFV2GYSVlWBZw6t6mvHf9IE1IA0WeKsAHFYYkMVBpyxZFspsC55vXJOdDtjaikpKECPk5emuydZJkj26lx0mZoZNsHA6H8pRZcsCc43oKioqPxkAymTQ15aXSr1aryOfz6vsuJ1KymbCV1DqQC1qGo1hQx5ZGwWBQCQRZ/AesNk9leyHSpzOZjAplUeCS0SZrYrZ6YVDw5fN5vPnmmyiVStixYwfK5TJ27NiByclJRWtmaIkCxu/3q7i3XtNjdR3cGPxsOBxWndZjsZiqjaHwoNeUy+Xw9ttvY2lpCUtLS8rKHQRFpedbJPU8EAiomii2muJzMgepd4rv9XpKSMv2PRSePM6k3W5jeXlZsS3ZtZoegcyJbmVjXmnsAWalLWnmDDuxkwRroeg5AFAhN3bHl4JY1tQBUJ5ltVpVLEc5p9KwZJEuQ8ss5mUTaBb2yhq2qzlvXDts8spGADROqEDPnDmDubk5vPXWWzh37pwK8+kRBV4n19vk5CRuu+02TE1NYWJiQim+lZXzx7e8+uqreO211/Daa6+pa+9nvtdWUhaQJAHpKegeES0csn5kk1OdtURyRCgUUgJYWogyzNOvkJ9MmBYKBbhcLiwtLalWNCQssCiUxAad/QSsegG6Z6h7qHoYjHlAeYQA55YEg2KxiFKpZCJY9FtBrQc91MdCXoa35Cm80qKncpIJfQpPyTyj0JL3hZ6U7kXpTXj75UHpHjSVOPcUH3J+5J4kEULPs/BvXjMNQIYIpYLRSQIAVAcPRhKo5K1qybYCTqfTxAQFoK6v0+mgXC5jeXlZKWMq1vXGRy8qGo1iYmJCtVeSTEnmuGZnZ5HL5UyRin7BVlLrgEJRPmjVjYyMYM+ePSo5TQu2Wq2a4vy0zBKJBHbt2oVYLIZMJqOapTJEw8LgWq3W17yKtEJJnpidnVXdC+j2y+Q+GZD0skjxlSwyq+adVNBMkI+OjiKdTqsiQxna6Ha7KJVKqFQqWFxcxNzcnFJSenK435ACWIayAoGA8hDj8bhiizLcIj0C5hyoVKjAeA8oVJif4nNUahTmem3LVpNzrELmjEjI/o1UUDz+RYbEmQtmGIpKmGxPvSWUDHNyjqjo5VzI3BzngmtNhvlkOHWrwb3GfVWtVk3svKWlJczPz6sc1HoRC35mfHwcN9xwA2644QZV90nqfavVQqFQQC6Xw9zcHM6cOYN8Pj8QjFlbSa0DWSBHy5Qu+NjYGDwej1JS2WwWy8vL6qYy7EePIJPJYM+ePYjH46pRK9snUcmx8K6fxAn+X6lUjh07hmAwqPJTbEVDtqM8qZeWPq36SqVi6oPGzc95dLlcqt0U+yEyLMpkNjdqoVBAPp/H3NycOiyStOJBUE6AtadA7ykYDKq2PiMjIxgZGVEeFq1jXZnoHg+vmbkKACoMyP8HmIWtVRHmVntPcm6otNkfkgdmsk0Un6OnyRxkp9NR9XO8brZNkkXw9LS4Bzm/LHjmg0xdmc/iPMu6K67bfhhCJNKQ+MHenlTcrIVaWlqyHKNcix6PBzt37sRtt92GnTt3mkhJXFuLi4tYWFjAqVOn8PbbbysPst/7y1ZSFqClxTBcvV5X8XJavpIuLUkEsi2SPE5A9sBjGEt6aXJB9HNRyPAcQyaGYaBUKiGXy8Hv9yuqr2z/xGsFoH5Ka5QNP/U6HzL6aEGzVoxjoUBh7Q9zDP2Ok+uwykcx3Cv7DkoygCxBYPhOCkyr3KTeBYFzKjuCbBT9Ikvo4T69HEGGPK0ULj0yvkcqX70kgWvkQnOjGwODwLTleCSbsVqtqnUjjWe9w40+nySj8DBENuCV4fh6vY5z585hYWHBdKjoIMBWUuuAoYB8Po+TJ0+quiFaZjxQ7LrrrsPY2JiJXVMsFk1tj9LpNMbHx1XPNr/fr9ooMYzFhdFvqwVY3fi9Xk/lpjqd84efBQIBpNNppaRpFScSCSU0V1bOH93B+H4gEDCRSqSSymQyGB0dVc17WT9GIcHi1OPHj2N2dhYnT55ULV76LUQIKwVFNpZsJJtIJFQnBSoqPbRHIcN8iFReUsnL830Y2tLPI7MSzP3ypqyKmmXukeD7ZGcT3m8KZXrh9ACkQqHwlkpKsiRlo1TmuiStXHpS64VKtwI0Ungo6tzcnDpnLBAIqNcYudDZinIdJhIJhEIhXH/99filX/olxGIxJb/ogZ06dQrf//73lSd1sdKarYStpCwghQZzM263W8XDpTUoT5uld8EwgWTVBINBdZooNwc3oQwpDAq4WbkBeGowvUHJ5iN5hEKIyXzmFKiwpbCicAqHw4r1xlyFtPAAmJLETGgPQhhCh7Rg9S4F9KQoYKUwkYpD96Tk3HF96ALfqov+RjyHrYQV5ZvXYDXOC+WHpELRn6cS0un2+jxzTDqxR/7dTwIT7zeVLsPnJIgwrGnFVpTzK6MV0WhUKSw9NFytVjE3N4eFhQVTbnwQYCupdSDp2K+99hrC4TAqlQpGRkYUU6vX6ymKL0N27A/W662euBsIBBCJRFSi2DAMlMtl1WOrVqv1reXIhSA3OCvOqXw9Ho/yLgOBACqVikn4kgothYVkKkUiEZWvI1mCCXSHY7VjNbt2Z7NZVU0/iN0lJDGASonKnG1n5EnGzIcAUAXUsvaHdGCGSmWHb12os36N5ANSsfs9P3p+Ts4Lw7qSYScp82zZw44PFKSdTgcul0sJUr0u6EJEHQDKmAJg6o/JNcdxWLH5tnI+eS1kMS4vL2N+fl6lDxit4L5kiJ0eJunm8Xgc7373uzE6Ooobb7xRUfypBIvFIsrlMubn57GwsKA65Q/C+iFsJbUOuOhZxe/z+VAoFJSrzLb2ei6AghyAYiixDigcDqvQRrVaxenTp9UptoPoGQDmQ/ZkyMXlcqFSqSjBWK1WTUeOULgAMIWoIpEI/H4/UqkU/H6/CvWRls0NJBmGZD9ms9m+k0t0WFmvsps250f2GWSuj3lPkgLYXFavk5I5LAp3mVPQ6e0yfCY9g34QJqzCfOsVatPAc7lcaDQaAKAa4urdIqSnYUUMkWE8hhbpWQCrOUAJXUHpXttWgnMiu4ksLi4qGrlhGIqYxGuU3iKP9kin03jPe96DHTt2YHp6Wp36zHVYLpexsLCAxcVFRQCTBtQgwFZSFwEXLgAlIOv1Our1uqmXms4wYiiQi1y3hlmLQWt5GMCNQ4XKxWwY5qPhmcNiqFAqcMDcy1B2W5BCi6Ec2Y5mkDbOhSC9B3lN7BXH3AgLcZlfoJKiJct1ITtw6Ed08D1SCWxlE9QLwcqTkl3t9d6VvN9cE5wzlhrIZL5UbOtFIKRnyznjvEjjUpIl9FxWPz0KOS7m5mQOj/kpYDXyw3DyyMgIMpkMRkZGMDo6qgqjdcOgWq1ieXlZhfMHLZoD2ErqgpAut9PpxNzcnGnRSyUl29xIgR0MBtHr9ZSgoQVYrVaxsLCgDqUbdAEsQ1M8dZhC1+VyoVgsmhL6Ml9Ca1/mVOg5OZ1OJQz4GWD1VFAW7koGpZ7L6Qdk/snKm9LPJWL3AoZJnU4narUaisUiOp2OIt3ozVMdDodihvJMIXqiwWBQMVBXVlbg9/vh9/tNh1Na5Vy2am64P0gVl0XtnB92HWfeqd1uA4C6Jho78hrogcpro+KT94Lf73a7FVFA5jm59qicZNEvjaJ+KioqbsM4z65lfkk2q2boj6SasbExhMNhjI+PY9euXQiHw+onc+L83na7jbm5Obz++us4ffq0yRjs9/6SsJXURaALZ91KlkqKwoEbQ2cSSWotcy7cFMMAmdAl9Nh/r9czhaWkRc/50i1+PXzH+WEoTGe+DRto7MhTd51OJ6rVKiqVilJS8pwjwBwq43rT8yxybenz049cig49DCofcn3IEB29dNmtnN8FrHY8l9fFuZFzoXv3UmnrHr6V96SHD/sB/m/Wi9HYo+EnozNsNBCJRDA2NoaxsTFFmqCCknPQ653vLiO7pg9SLoqwldQGwJsmWUL8nbFt5mmkJU1qebvdVvkJWmzNZlO1MhmWcB9gfXCh3PjAaiiFLW1CoZA6wG7Hjh2qwSWTvQzzVKtVeDwe1ROQuQgACAaDiMVi6kReGfbZ6k21nhclBR/zktVqFQAUO0sqGvZs1HvsMe8iz9ECoDyCUChkOr6CZBaywGT9jMyp9GOeqJD0BrL0clwuc4d7matjbogKSYbTOUdS+QBQvTXJHGWxL0OILAwGYPKgJINQhlr7mf+USluefUVDkDVPrNf0+XwYHR1VTL5kMqm6ncj6Q7Ig2TH/1KlTyGazJmNwkLwpW0ldAuRG54bRlRU3DpPAzDnQopPHJchjwYcJ0sKUYSU5JwwrOBwO1XGBB9h5vV5Fg5XHbcizfni+D+eG38GYO/9PvzaRlWKSc8E8ZrPZXOMxUIHIxqd6MbfsykEvnU2JGTqjspZsNamg+mUZy3UhSRMyxCep8/wM94xOK5csPADq2mRYUeY1SfVnkTi/X4YVgfWLhXWyST8FNQ1iet+BQECtj2g0itHRUUSjUaTTafh8PoyMjCiWLMPpJI3I76SHWiqVkM1mUS6XB1YO2Upqk6DXKsiQjAxtyK7Vg1rvc6mQCorXzyQ/lRMtPbK0mNei5e/z+ZQnRWUkBa08hFLmrXRSxtWGDKdJQSx/yvdIujkFoGy5ozP5+L2cU+bvyA5lKYM8jJOeBRmVejPVfipyyXak4JTMWMJKKUijTxpGVEpSkbONEudKrhc9HM0wslUj3kFQTISeh+OYy+Wy8gp5XTQAdBIXv0fCqv7Kqnv6oMBWUleI9cJf3KAytOFwnD8Dplwuqyr6Qeo9dznQwwK8bnZOZxKXDVXlwZHtdlvNhc/nUwdBJhIJVVsUDAZhGAZCoRASiQQKhYI6PVVaxHI8Vwu6gqIwkAxPKSSYW5EkAElz5u9SMMoiTP4PHgRJplYoFEIoFILH4zF1+eYBfVxb/c4xyLxQMBhEMBhUBaW696j3GNTJKDqJgfMu6+4Y3kskEqZzmGSLMxpJjUbD1MmCRoJOOe/33pQ5KcM4Tzufn59HpVLB5OSk2gNU0JLar38PwRo8nhvF2qh+9Si8GGwltQlY74bSgpSUYG6WQV0QVwLpTVmFeQAoinWlUlFWYa1WU7kDyYJ0OByKYqtTrCWRYCti51YelM7o05WUnqTmPZcC0WoN8Dul90Ehz1AWv5uEDB4pIZUT0H8haxX2YyiYORA5b7p3xZ9WORLZWolsUdlqSa4Rmd9iDkqvh9LvQ7/nTkKuIXaBp6IJhUKq6FfuHdm9RYKUdrlmBtlYtpXUFWK9BCMt4FQqhUgkokINPLCN1fODvDguBXq4T9LyKSxYmFuv1zE3N6dyds1mU+UQeBAkDwYMhUKKuURBxFg7WV9WjVivFmRoT3o9kjQjSxT0uhurehx+LwDT2Vrj4+MIhUK47rrrMDMzg0gkorwE5vAKhQJOnTqlCp7lESb9MoCkQpdMNFr7NDwYiuN8ssuEVORW10AjhUQBhviY59Rba/FAyEajgWw2q7qp6wchDopil+BYOD52YKlWq3jttdeQzWaRyWRQKBQQCoUwOTmpvFWe1qAX+tZqNZw+fRpLS0tqXgbZaLaV1CZAv6ncpF6vV1m/XCQsTpRNMAdtUVwJdO9C5uNarRZKpRKq1SqWlpaUgiL7kZ09otGomju9hoqeGenGOnFhKzwq/SE9O6msqKT0fIsVzRkwH6zJoyzI0mJCnApaFgMXi0UV5mPoahCEjRyD7kkxXEfBS2KAJDjoilYqcio9FqkyBCrB8CrbTrGTOH+XHu0gKigJKnOG/drtNhYXF1V+m4epMu/r9XoV61NffyRM8ITtQQgNXwi2krpMyByMhIzDh0IhxONxJWyZg1leXka1Wh3Ifn2XC2nxMQRFevXZs2eRz+fVmVBM8EvyCBvTMmfAMAbZcT6fDwCQTCaRyWTU5qLC5/++mhvNyluUhcv0ghi2pCBmYl4WiZKVR0+cbZOi0Sji8TgikQiuu+46xGIxTExMKA+KJAKeL5TL5bCwsIByubxG4AwCJIOOSkMqcQCq1ZjsewmYlZxhrJ65xRZQPp9P0ayl98T3kRBQLBaRz+dVHop5POnJ8n8MMuQeYy9D2XEkGo0iFArB4XAgHA6rgmWuNa6/RqOBpaUl5HI51Ov1gVVOhK2krhC6sqKS4vktrFtg/Js9uPTmq8MMPSlrGIY6gr5araoixHq9rrqY86eMtTNnUKvV4HA4EAwG0Wg0TJ0K+BkKZXpTMoSmj+lKsR6jT/bTYw0TD5KTp+bK88J0OjWwWtvj8XiQTqeVUrrpppsQi8VUPQznl8bOwsICzp07h1OnTqFWq6mC4KsxB5cCGQKXheusgWKIVNbRsSsHW0LJRrDAecFMJUzWqNvtRiQSgdvtNuVW+JNHq5dKJSwsLKgcKKMY/ay1u1xQCTscDnXMT6lUwtLSEmKxGJLJJFwuFyKRiGo+wE76NJbY7ebcuXPqNPFBngNbSW0iKLxkI03Za4veFC25QV0UVwIudoZsGM6R7CpdMeukAz20x3l0Op1oNBqIRCIwDEOdUyVDRRei3l5NyHvPfImkX8tcC+ubZLiQIc5kMolkMolYLKba3jA8RiFOL5VCStbbDZKwkeFNWTBLRS17EMq8HnNY9BplHo9eqiwENgxDEQFkrVWtVlOhPcmyHIbw3sUg51bvziINZ1miId8re2IOOmwltUmQ9UGkw8bjcUWnNgxDnYuUy+UGrpv3lYLXQSFAi9jlOn+KqGQ4ymQ5PSGpjJj4HRkZQTqdNlnOPDiSBIxisaio/cBqe5zNnFep/PT4Pl/jNbDjeSwWU4xGACo0Sa9iZWXFRJNmzokHZAYCAYyMjMDn86k8Qq1Ww+LiIqrVKl5//XXMzs6iUCgoOr88CHIQ1pW0+unlsU2PDIuyUJlKXv6UbFiPx6Ma0DKMVSgUVINeNkmlx0UiCZX6ermuQZiry4G+DgHrs8ZoNNJArtVqKJfLpqM+Bhm2ktpkcOMxZi6LTylstqsnJTc9LTapkGSbH50hJ/M6Ou2a7C127KAwDoVCaLfbSuBZFdNejevTIUOAvAbZiobCloQPKimSQ7xer+qzNjY2htHRUfUalTw9xmq1qliS+XxeeVKDmN+UXhDzI7TgWYTM9UHPmaUIXCvy1FnZpJiCmaSLSqWCcrmMTqejlFS5XFYsWnlW13ZQUMDas8WsSiIkcYJ7UqfhDzpsJbUJkDmKYDCIiYkJJJNJjI2NIR6Pq9g6PQyysIZ5g2wEFEDAWuo2lRXrWkKhEEZHRxEIBLBnzx6k02mMjY1henradPKvzEFJ9pxel3Q1IL9fD+3Si2Izz0Qiobwk2caJPw3DgM/nU33meAgkC6ABqNoXHkxXKpXw9ttvq5yCbAw6aOwsnc1IphkLSFl4Si+bIT7+zXljVwRJI5fd0UnEIWuP4T4y+pgHs+omMShzdbng3qInGolEEIvFVKhYp5/L3O8wXbutpDYJFFhUUuxCHIvFlKt9LSkpq3CY7jmxloytk6anpxEOh3HjjTdicnIS8XgcY2NjptwDlRTzUPJ5+b+vJqhsdGaf3+9XVGge5Mg+eyTTSEXL98u6KoY82+22OsaFB9Ll83mcOHEC1WpVnVIsG8kOovCVSoqsREkyYVK/1+spT5lz5Xa7TYXfy8vLau80m000m01ks1mVp6NHyXZBFMgcxyDOz5WCYWYqqWg0ilgspjpxyN6IsnHvMM2BraSuEBTALMCMRqNKQTFERcjk5TAtksuFvF4qKeC8Qmc4jMy1eDyuileTySQikYh6j7QEmeegJa33QNzKedUFHwWBXnsja59kvkUSQjg3vK5ms6k8h1wuh1wup4gS9CyslNMgrSvdm6KyajabyqtiSLjT6agiZam06SW1220Ui0VFguBP2fVdhvTWq38apPnZLMiyF9mAWNbyAauKymp+Bhm2kroCcHE4nU7EYjGMjo5i165d2L9/P8bHx7Fz505Fo2b9h7RmtjNkaIvWvsw9jI2NIRQK4YYbbsDU1BTi8Timp6cRCASQSqUQDoeVh8KNJCm07FPHIlbZBw64OsJIDyvqG52sKXZwZ+NT5lqi0ahSVhTCtHSZZysWi4q6//bbb6NSqWBhYQG5XA6NRgP5fN7UpFiv9RkkcI6A1a4gPJqGHhEJM/xJAgXnlJEHsvV47WTwyXCeXiQt18AwCONLhUwz+Hw+dSgmyVrSawdW2cXSwJNtxbaiGP5yYCupKwQXCvMLMi4sz7LR2+IM4mLYbPAa9VwMQxTsqpBIJJQ3xRCY7PItIRW9TrvdamtZ9xJkiEkSRwi9vkoKD36u0WgoEkChUFDKmCw15lusWvkM8pri+Mj2M4zztXRM4DPEx9CtpJbX63WlkOiJsaWRLMq1uv+DPCebBSvykVxfhFVLrmGYH1tJXSakcvJ6vUin09izZw8mJydVTJjFnBQu9XpdPfQjsbcLrK6HAkcWWlJZkTRBj0OvjaGCZ7sf5iPkOVS6FX21r49hEwpIenL0Enu9niIHGIahClDZm47hGHn+U6lUUjmW+fl5NBoNLCwsqK75DI0x3zIsxagyYS+FJO+bZPK5XC5Uq1XF/OPc8ZrlESey5dG14DVZQdbZsfSBBgDnSYaSmd/jYaxkPg56KNRWUlcA0mLZnmXHjh1Ip9PKE+Bmk8VzfGxHCroVZC7JKnFLujbbAsn+bToriSEKCikqvK1QUPK7eV+BVcYmFZHf7wcAVCoVpbgAqDOeqKS8Xq86urvdbiObzaJer2N+fh5zc3OqvxpDM/KYj/VCWoMKPVdH5cR7rDfnBdYaNvxd5jn53cMwB1cLnD/2M9T3DOdUeqWysfOg9Hm8EGwldQWQi4FNU51OJ3K5HDqdjjqIrVgsYn5+XnUvHpb6hCsBF72kbXPTMLfSbrcxOzurWiAtLCwohR8KhUxhvWKxiGazicXFRczNzWFpaUk1yJS5ma3ypoDVMKb0qFwul7L8vV4v6vW6yq+x7ok5GJICeL4WO1yz8JXeo35SLccwyIIFsF4DVq/RY5aJfj2EKo2dfrd9GiQwz1SpVOB2uzE3Nwe3241EIqHyojSUcrkcstkslpeXFeFkGOSQraSuABS8AJDNZuFyuVAoFFR+JRKJIBgMYmlpCSdOnFB9+1hsuN03mW7tc75kB4Hl5WX8/Oc/V0lfv9+P3bt3Y2xsDPV6XeViFhYWUK1WVUNVCnR6KNKyvtrXJK9N/m8KCzL3nE6nKQzDPAFJE7KfHa3a9QpPBz0ksx44dr09DwBVO2VVfG2Va7sWQ3oXAkkPtVoN8/PzKJfLCAQCOH36NCYnJzEzM6NyVA6HA6dOncLp06exuLiojCG748Q1AFp7tIp9Ph9yuZw6kiMQCCCfz68562dQGVlXA7rnwdwK29msrKzA5/OpY+QjkQh6vZ5JSS0uLqJWq6mmofQ0+t2kVwpRmWtjKIs1cvrRHjJfSWtY5pqGXTnpWG/8UoFZvc9WTBcGDT928WCbMHYsIS0dgIo+sMmuJPYM8tzaSuoyQYuQ+YJcLodyuYy5uTmcPXtWxYhJR2bh5fLysirkHeSFcTUgQzaslWH9i+w1dvLkSfj9fhN7j0qNOT09P9Ov65GQbX7IYmPRMbD2qA/phW1HxWQFq2u6kAKzsT44P8xf8sQBthUjnZ/rj6cQtFotZegNcgkDYSupKwATwgAUWwYAzp07ZxJI213wXApkmAyAOl1XYn5+fquHtSm4Fg2Py4E9R5sLyfSs1WoA1h4vAwyvV2orqasEqwUxTAvDhg0bwwudtKI/P0xwXvwtZrzwwgv49V//dUxMTMDhcOA73/mOeq3T6eDRRx/Fu971LoRCIUxMTOC3fuu3cO7cOdN35PN5HDx4UJ1C+tu//dvKC9kOkGGbQTo6wYYNG9cWhq1cwQqX7EnVajXcfPPN+OQnP4m7777b9Fq9XseRI0fw2GOP4eabb0ahUMDnPvc5fOQjH8Err7yi3nfw4EHMz8/j0KFD6HQ6uP/++/HAAw/g29/+9mVfSCgUwszMjKlX3rWM6elpVbNDBINBzMzMmJqxXsvYtWvXunM0rBt6szEzM4NAIGB6LhAIYNeuXeh0On0a1WBhZmYGwWDQ9Jzf78euXbvUOWfXOqanp9fM0UbhMK5gNzocDjzzzDP46Ec/uu57Xn75Zdx22204deoUpqam8MYbb+DGG2/Eyy+/jP379wMAfvCDH+BDH/oQzp49i4mJiYv+33K5jFgshlKphGg0CuC8d3b8+HF7UfwC4XAYe/bsUfMDAIVCAcePH0ej0ejjyAYHoVAIe/bsUUezA0CxWMTx48dRr9f7OLLBQSgUwu7duxGPx9VzpVIJx48fV/mPax3BYBB79uwxzVG5XMbx48e3VYToSsAjeBKJhHrOSo5b4arnpEqlEhwOh7qBL774IuLxuFJQAHDgwAE4nU689NJL+NjHPrbmO8joIsrl8pr3JJNJvOc979n8C9hGSCQSuP322/s9jIFGPB7Hbbfd1u9hDDRisRh+5Vd+pd/DGGhEo1GTjLNx+biqcZ9ms4lHH30Un/jEJ5SmXFhYwNjYmOl9brcbyWQSCwsLlt/z+OOPq6atsVgMO3fuvJrDtmHDhg0bA4KrpqQ6nQ5+8zd/E4Zh4Mknn7yi7/rCF76AUqmkHmfOnNmkUdqwYcOGjUHGVQn3UUGdOnUKzz77rCnemMlkkM1mTe/vdrvI5/PIZDKW3+fz+eDz+S74P4vFImZnZ01hwWsZJJLwKHLgfOh1dnbWztv9AiRJRCIR9Vy5XMbs7Kydt/sFAoEAZmZmTHu4Uqng7bfftufoF/D7/bjuuuvWzNHs7Kyd2/wF/H4/ZmZmTPnfjWLTlRQV1IkTJ/Dcc88hlUqZXr/jjjtQLBZx+PBh3HrrrQCAZ599Fr1e74ryJa+//jr+5E/+BHNzc1c0/u2CvXv34rHHHsNNN92knnvjjTfw5S9/GadPn+7jyAYHu3fvVkxU4vjx4/jSl76EkydP9m9gA4TrrrsOjz32GH75l39ZPffmm2/iS1/6Et56660+jmxwsGvXLjz22GOmHNTs7Cy+9KUv4fjx430c2eBgamoKf/iHf3hZvIFLVlLVahVvvvmm+nt2dhavvvoqkskkxsfH8S/+xb/AkSNH8L3vfQ8rKysqz5RMJuH1erFv3z588IMfxKc+9Sk89dRT6HQ6eOihh3DPPfdsiNm3HiqVCo4ePYrZ2dnL/o7tBJfLtcbSrVarOHr0qOn+XcswDGONpVutVnHs2DEcO3asT6MaLHQ6nTUsvlqthuPHj+O1117r06gGC+zbKVGv13H8+HH87Gc/69OoBgv1ev2ymY6XrKReeeUVvP/971d/P/LIIwCA++67D//+3/97/P3f/z0A4N3vfrfpc8899xze9773AQCefvppPPTQQ7jzzjvhdDrx8Y9/HE888cRlXcBm4UKdmG3YsGHDRn9wyUrqfe973wWF90YEezKZvKLC3c2G1XEB+vEC8r228rJhw4aNrYHduw9rldBG32vDhg0bNq4u7P44v4DeBPZiysqGDRs2bFx92J6UAEN8trdko5+wCj3bsHGtwlZSG8B6J4eu523ZQsXGhSDPGuNPq9/1IxbkOVzX+hrT956cN3uOrKGvO/13K1gdM7TV82orKQ36DbDaDOv9bRUqtDeKDcJKILAjvTy9l79LAaE/rmWP34roxHm72HH01zp0g0j+tCKIWZ1HtdWevq2k1sGFLIz1Tr28EEOQf9sw43Jyf8M0j1IoOJ1OOBwOeDweuFwuuFwueDweOJ1OeL1euFwuddy3YRjodrvo9XpotVpot9vodrtotVrXrEfFuXQ6nWr+/H6/6e9ut4t6vY6VlRV0u12srKwM9VlKG4W+xjgnTqcTgUAALpdLde5xOp1wu91rvM+VlRX0ej01b91uF+12G71eT/3kKcDyrLyrbTDZSsoC6wlOq5AM/7baCFKBXevWL2Gl4K3CEBLrnWw8qHOprxNdsIZCISUwgsEg3G43IpGIUlRutxsrKytoNBrodrsoFAoolUpot9swDEMJkGtJUXEOHQ4HvF6veoyMjMDn88HtdsPj8aBeryObzaLdbqNer5uE6XaEXGMOhwNut1sZP5yj0dFR+P1+xONxxONxuN1uBINBuFwuNS/dbheNRgMrKyuoVqtotVqo1+sol8vodDqoVqtot9vq0ev10Ol01jUANnO+bSWl4VLitZfynu26SS4GfT6lxcefViEvQj/hWJ50LDfIoMzvegrK6XQqD8rv9yMQCMDn8yEcDsPj8ZiUFD0CwzDQ6XTg9Xrh8XjQ6/UsQ1rXEnSlT+Xk9/vh9XoBnO836HQ60el00O12AazmqbYTrNYY11AgEEAwGITf70cikUAgEEA8HkcsFlNKimuJ68ztdivjx+l0otfrqT6f/P5+rDtbSQmsl8gmLmYxrKfgDMNQC2K979kusBLSfFAAU2A7HA74fD4lvL1erwpFuFwurKysKKut2Wyqv1utlikEYRX+2uo51u+9y+VSP51Op1JItGwjkQhCoRDi8Tg8Ho96jeNutVrI5XJoNpvKenW5XCrsJ5X0dveopCDWFZTP54Pf70cymUQikUCj0YDf70ez2cTc3NyasN92gB7a4zy43W7EYjH4/X6k02ns3LkTgUAA6XQagUBAGUfcf8B5D4ph5Fqthna7DZ/Ph1qtptab0+lEuVxGr9czGYlbBVtJaVjP8icuZsVavbZeEnK7wYqlJgW22+1WCogKiR6F2+1W+QX+3el0lHLi3zJfs7KyAuC8lawnf7dyrq3WjJXF7/f7lbKKRqMIh8NIJBJKSXk8HqV0Go0GKpUKDMNQnhTngUbPdl9PVrAKn9IziEaj8Hg8aLVa8Hq9WFpagsvlUutju82Vvr68Xi+CwSCCwSBSqRQmJycRDAaVkvJ4PMo4ZNSi3W6j0+mg1WrB4XCg3W6j0Wgow5B7Vs6fraT6AClYufm5AYDVMJRVbPtC3pe08mn9btfNwp+cP92LkGEuj8eDUCgEj8eDeDyOSCQCj8ejrDx+jnmFTqeDfD6PZrOJcrmMUqmETqcDh8OhLEHOLzA4OUBdoEohwTXRarVUwpphPirn5eVlNJtNZeGurKyYQjtU/tvZQ7cyfOhte71epexHRkYwPj6OWq2GbrercjLbjTSh55/cbjcCgQCi0SgCgQCmp6eRSCQwPj6OyclJeL1exGIxZQAxpykjFJ1Ox5Tn5PxKo1JGQayMd4nNnm9bSf0CVrFdWhBUUjJkoN8k3kD5mmTJ0OrfTpBzIPNKUsm73W6EQiF4vV5EIhFEo1H4fD4kEgn4/X5kMhmMjIwoxSXDohTQDN1UKhX4fD4YhqFIBLQC9fzUVibLrbxrGZKhQqFHBMCkpKiMgfOWbbPZVOG+VquFRqOhlJn0IBjmk3mq7SaQrX6nwvf5fOq07kwmg507d6JUKikPQIZPtwN0Y5CKOBQKIZlMIhKJ4IYbbkA6ncbIyAgymYzag06nE81mUyklEiIYTqZiopKiQeXxeNDtdpXConF4MZLTZsJWUlhr8cqbJJWUFIS610SLQ76P+QNgVWFtx4S3laVLIeLxeBCNRuH3+xGLxZBIJJSS4k+GaYLBoBK0DGlRufv9frTbbWU8UGBLy3LQBRLpu51OB+122xQK5TVTKVFZcQ1Jui/XKY2mYbj2zYT0pvx+vyIIeL1eteZI7d8usAqjkzRCTyoSiSASiSAcDquIhcPhUGuuVqspr7xSqSiKebfbNckuaWTq3pNuOGzFurvmlZSeO2FNQSgUMtVg6ItEhgIdDofaGLLOoF6vKyuYNQb8fZiFilUORq8BikQiSCaTCAQC2LFjB8LhMNLpNNLpNHw+nyIMBINBlYMiO4vhh3q9Do/Hg0ajoRK5zWYTfr8fwOrcA2sLXuX4tmKurWri5N+klHc6HZVzktY+FVGj0VDUc+bjJLPK7T6/ZZln4fdZzcOwQ1fA9JCdTif8fj/C4TDGxsYwMjKCkZERxONxAEAkEjHl77bLfEjZ43K5EAwGEQqFkE6nsXfvXkQiEezatQvJZFKF1tvtNgqFAhqNBhYXF5HNZtXa4rpxOBxqPmWI3u/3w+/3o9frqX3dDyP7mlZSurDVk5DrFb7pzzkcq7UbZJ0xz8ANQuEild2wb5z1lBVDW0zixmIxRKNRJJNJjI6OmuLk0uplKIxeAnML/MmNspG4+KCBuQDgvBIGVj0ret1UUvV6Xa0jwzCURSy9eob7pKDZDmvqQqDSkutM0vm5Rhia2i6elJWcknk5kkai0ShCoRACgYCJ7NBsNlGv11GpVFAsFpUHRbnE99L4k8XmfMg1ttXe1DWtpIBVujBDB8yZxGIxZVn4fD4AqxY+rQ55g3izpeXGcE2lUsH8/DyazSZyudxQV8FbhR2YI6AHRQrs9PQ0QqEQdu3apTZRNBo1CREKYxna4zyTeUTGUa1WQ7VaRblcRqvVUvF1eiHr1VD1C7T8+dCflxRy5pyYo5LXINcoQ6LyQS+93W6v+f5hh/SmpLfIPcSwMq1+euOyg8Iw10hZRXCojOPxOJLJpPIkSUYyDAPlchn1eh21Wg1vvvkmyuUylpeXkc/n1fpwOBwIh8Pw+/2mDihU+LVazUT7l/PPn3a4b4sgrRIK2UQioQosA4EAAKiq62g0ilQqpeK9hmGYLHyGAhn2y+fz6Ha7qNVqKJfLqNVqQy1ApICUzDW3241wOIxQKITR0VHs3LkTkUgE09PTKu+k5/mkN8B5Ywir0+moB61BKirWS3GOqeD6Pa+6UJWKSiolCk7+Tu+billC5vmopCSbkSFB2a6Gn+v3fGwUugC82Ps4n6wR4oOGojQOBsFguVJY5XsjkQhSqRRSqZQKrVNJVatVLCwsoFQq4cSJEygUCqhWq6hUKqZ9y/lhmoPzKSMcugdlU9C3ELqgZSKSiikYDKrfeWO4QKxCCRS0pFyTTOH3+9HtdlGpVJDP51XSctg2jx5e05lrksFHajDb/sj6JgBrBLYMV9E7qtVqKJVKqNfrKBQKyOfzqFaraDabSjlJgT8oVGzd0tQJDxQAfA/zLCTW6PNsFWaR/2e9UMywYaP3TXqWUjlJhq38zn6vh82ClC8kjLDFFq+bHSKKxSJyuRwqlYoyjJkTpaKjcc31SPapNK6kEahHKrYK16ySkpuabVUCgYASrIlEAslkUrFnAKiENgWOrIPiInG73YjH4/D5fBgdHUUikUC1WsXMzAyKxSIKhQIKhYIK7wD9F6obgVWYjx6oz+dTdRo7duzA6OgoxsbGMD4+Dp/Pp+qfWM/EsJa8fqmwGMarVCpYXl5GrVbDiRMnsLy8jEqlglKpZArnSO+hn4pK954YipNrg1R7JqRlI09JMZfKTbdi5ZwBqxT0YWM7SmzUg5KCmqy2eDyuQl0yF8P5HaZ5kJDXLFtrRaNRBINBjI6OIpPJIJFIKPo4KfgnT57E8ePHUavVcO7cOdWXr9frKaORBAnJCiRzll49aev08OV86grras3zNaukCClwdY9KJusBmAox+eCNl4KB1kkwGEQ4HFZ9xAAgGAwqMsCwCRJCt9xlQ8tAIKBasFBoSIFBL4nMNULOJS0+hvf4qNfrKsSn53WAwVL2cizS45FrTCrpjXpD612jbkTI5wZpXjaCi+0Lq/yMDLdvlfDcakjDUCcdydxmvV5HvV5HtVpFvV5XCkbOg/wen8+nSju4LinfaFjK0Cmwtc2er3klBaytu2ACliEZJrLpSTFpT5o06a4ulwuxWEzlq+hlUFi4XC4VQy6VSmg0GgCsO1kMInRBKtlFyWQSoVAIsVhM5fK4uFmo2mq1lJIhg00KFvn+VquFUqmEbDaLRqOhYupSSVkpgn7Po57g1z0emVOgF8W1RwtWKmGCAqPRaJg8NHapkIaW9OiA4cpNARfukakrfIa9GGIHzoe8uFeH6bqtwLWkM49ZusD6p6WlJaysrGB+fh6VSgWLi4uoVCpKdkmmXiAQwOjoqIp8ZDIZhEIhRCIRAFDGYblcRqFQUAqP9XuS+GUTJ7YIer6AVgUTi0zks/CNfdWYN2ExnGSsAauV8RQevV5PudatVsv03mGCtGQZemHDVBZWMvxARS6VuzzzR84zhXStVkOr1UKhUFBNVrlJJEliUKErBz0vJdmN0oCR3ry+LqikJKOP60cPC1mtqWFTVBcDr1UW8EriDSn92wFWuXNGKLivKpUKOp0OlpeXUSqVUCwWlaLmd1C2BYNBFSJNpVLquJNgMKj2F4vKK5WKqvW0am68FbhmlZQeV9W7ATAsJW8EGWWy4JICmAunXq+jWCwCAEqlEoLBoBLATGrKnlgyHyPHNeiwCrfIqnUq816vh1qthk6no+aNha3Sk5JJWiqpUqmkmHyMh1sJnmGZMz0BDazWO8lQC1vPEFZ5KemBso5FFvbSo9KVJD8/zLAiOl0o3LcdIAu69fC5DM01Gg1lCPJzDLvTiGTEQ3qgjBS1220Ui0UsLy+jWCyqqIbcf+tFMa4WrlklBayGZmTyutFowOl0KstBWqcyzlsul9HtdlGtVk0NLR0OBxYWFlCr1RStEzgvaHgIG2PAfH8/4rxXAp1wwuuRzCAu7G63i1KpZIqVy84bwGrdC0MJVFJk9zGHNWyMSDlOChEWKstwHQDVk1B67oT0uOTnZEslCix+BwUPGYN6+HCYoedTGJ6notLzlcOyXi4EXjOvT3o7BHvysfURP8doTiKRQCKRQDgcxvj4OAKBgGruzH3aaDQwNzeHxcVF5HI5FItF1R/TSknZ4b4tgFzIFCQUrmRbATCFo1i7I9/L76JwdTqdSijTCuLCkfFhCh1diAy65StDEPKnFKacT3miJxURBbH0ZGVBqwwvyN51wwwroanPoW4x02uSoUAKLCoimYeS3wesMv/0PNUwQ4aapQcFrBo88uTiYYZOhLEi1VB26IYNjRh6UvIgRKY0AKiQIeUVH7IO0Yo0YYf7thDSki+Xy2i324jH46qrhMPhMAnbRqOhuggz3Mf31Wo1OBwOVR9EL8vn8ymGXygUMnlaDI/JNjkbFShbLXTkRtEtermB6P3w6Gkq71qtppSXVFKcS+aw9KOqhy0cSnC8km7O65G5Stn7MBAIqDkyDMPU6od0fr6fYdNut6vqZSi46ZXJMejjGkaQOUsWKTvCkN3Gmrpmszm0npQe7rUyZLj3pEEbCAQUqUmSubxeL5LJpCqrIeu4Wq0qUlIul0Oj0cCpU6dQKBRURMOqa8pW4ppXUroXJQ//kklHWeND95c/ZRhqZWUFhUIBzWYThUJBdVoIhUIq4S97jDE0I+t9mKOhotI9Kvl3v7wtnemnP0g0YY6PD9lsV4ZlZAcJelGyLmPYhI3VvbHqgqBbygzPSKUsCy2DwaAKEQLn81wUVPzJz+klEvwfwzSPVuAcyVyoLAmR7L5hhm74yf0llZVcS1Zrh6cQ8Ph45pKB8110qtUqSqWSUlKlUgmVSmXdEB+/e6twTSsp3lgpOOQC0Be/DO9JpSUL3BiuoldVLpeVpUfBIePpAEyLQbK99HoXOW4ApnHL57cCVmFSPqhc9E0mQxBSSVnN7XqbY1hgFZbRO05wLmQHAPaek9azZJsyjykVHuvK6JFT2fN7rMYyTJCRBf7O+ZB7hMpbeuDDuHZ0SGYf2bRk49EjorKSuVvKmng8rlh9gUBA5dKZw+KjUqmYzpwaBAUFXONKipDhJ31B0DtiOFBa+XxISjT7zBmGoeoM/H6/SZHIRo4ATHkr5sB0916C30XBvpWbUU+aylwdxyPnRLf+yGCjcJGfo7K+UMujYYOcL72JJ7A6P1Q+NGDYB1GekCrnXdKBeewHu3pQWOne7bBD5ug4R3xe5qVIKBh2TwqwPt2ZZJFwOKxOE2BXHL3xLo8dknPFTi5sN1YoFFSHdHmemVUUox/70FZSvwAXg96iXno3+g3TQzXyJ2AmW0jBLOmztHbkhqLbLscjlZU8SpzFoP3wOGS4TicDSC9BepIy/0aPSve6BmFjXA3o1yFzSzSIZJ2e7AIgWV1yXuRnqaCkwOb7tsNcrhfukuuGeTidITns0A09ndnIxsPcj7LHKLuc6yeEX85a6Ee42FZSWF0AkgHDpCytUwoCKi3GdOU5UXoYgqE/MvtoDbHvWDgchsfjQavVMoUWaUXLXAQXomEYqnEkC4nXqx+6mpAsKioZuYH4c2VlBR6PR3lKfJDaWq1W1cLXcyrDGuoD1u88wTXE+8w6OpJH2FaKeUxpATO/p3dLZxEmsOrJy/oz3SIe1jmVe4wlHAydcj5Yp0ivYBhh5fXKsHA4HFYd0MfGxlQPQxqxegSG95sEJmnoyAYGNJqtCBn9zGXaSuoXkBuAQnY9mqtVSFB6YlY0Yt5g2RqHrU28Xq9JkFBAsZqedUiRSESFdxh338quFXLR8m891Ki3b+n1euoQNjmfFKQMn8o53g7J/YtBekGcM8Mw1vRlI7lGEmr0UCibqsqSBsAsWIZZORF66EvuNXqSkoU76J1JLgXy2ik76EkFAgGEQiFTTSZ/cl7k+pGRIMkG1WXdoISIbSWFVcUhLbRgMKiOoQ4Gg2rRRyIRU5EpKegUzC6XS7UFmpycxOjoKHw+n+loZofDgVKpBL/fr45DZxExw2NsVUKPjouG+Rv5PVJJbpUgWo/MoSspYPWkXQrYdrut5pTxcCZtqbgGZYNcLqxYWcBqNw52laBykgc90nsHzs8dw1c8QJOMPilY2MWDBAppQGwH6WvJCQAAH+1JREFUAoEUqKFQCGNjY0ilUqb+mixxYNeFYVZS0mh2Op2q8DYWiyGZTKqjcGRLKO5/PeRJEokkVTAEHw6HAazuUXY8dzgcJvq5HmLeyvVkKyms7d0nmTMEQyuRSATVahXhcFg1d5QdJ2RSd8eOHUin04o6zNdcLheKxSK8Xi+azSa8Xi/q9bqyngOBADKZjLKQAoGAaivExCaT5yQiOJ3OLduU67EO5VxSSTkcDpXU5cbrdDoIhULodDrKGnS73SgUCgBWmY3bwavSFZRsZ8PXdWsXgKlQl/edPdoMw1CHc9IgYG6S0BXUsM8hsGoAhcNhdQwOlRT3Yr1eR7PZNB0FM0yQe0oafH6/f42S4llSlDs0YqmYqtWqqbuLTAuQVCEbHFORsfkzAGUw6iSmrdyXtpISYK5JWiZUXGToRSIRdSP13n1SuLpcLoyMjKizXpjfogUsz2uhsJY5K1pIsgGr7vExzKNb7Vd78ei5Fb0LhySL6CxFhiQoYIPBoMpXsTO4PMH3ShO9gwLJEm21WqoVDa9JFnEzfEUBUa/XlZfENjg86E8P2ehEgu0E3ZiUB0eyyF6WcwwbpPGnpx/8fr8yWKmYqDy4LpgKYG6uUqmYcpIyGiP3J09rYA0e9yTLG/j+fhk7tpISIGGB/ayA88J0ZGTEpBh4o1jhLmtW2GkBAOLxOCKRiNpcwKrgoEXUarWQSCRUtwWGDtmxgglNWtUMJ/LgPBk/vpoKSlpPfDBk1Wg0UK1W1aLm9TMUJavgeT3SA+TmyOVycLvdqn2UFDjDSkfnXNEo6fV6KBaLaDabSvjI+8fDEOVnWVzJ75DribnLXq+n5pVKbjtBeugMn3NdraysqI4JPFB0GNoirRfSlsYxm8CmUilkMhkkk0nVHJZhYTZj7nQ6yGazqNVqilIOwMTy8/v9AFa7j1DWUKawtIHnwbFpgQz5bbWHaispmIWerlBkopLnJMlkLQUPFYw8K4nHV8j/oz+4SBgGY05ivdCNDN/0UxBJb4qelKyTYihBjh8wW8MOx/n6IHqSbB3FvKDeO5FKcthCgFZzJa9FzgfXEACloHnECa1mCifJ0pLe6iAlvTcTvDZJbuJ1ynD4MIQ4L6Sg5EPmd2XPPUYkaLiQTEWDhidYM9yuE7xkWJmGN71xeaYec1X9XFOXrKReeOEFfO1rX8Phw4cxPz+PZ555Bh/96Ect3/vpT38af/VXf4W/+Iu/wMMPP6yez+fz+MxnPoPvfve7cDqd+PjHP45vfOMbphzQVkG3dCuVChwOBxKJhLIiuFjoEtOi4+ekAGICW1I56WHpyUdZL8Xv4XcUi0X0ej3leTAf0Wq1cObMGSwtLWFpaUklOrciOS49SApUhhjY85C5umAwqLyFVqulTu2VdHVgVbgyD9doNODxeFQVPAXzxQ47HHQwTyBr3UidpuB1OByqYFySKdjwk9/jdDqVQUMFBkB52QyVbidlJb0L5qRisZg6VLRcLuPMmTPIZrNrTqEdFujsRRrGwWAQ0WhUHRtPRi/zk+VyGQsLC2g2m+rQQ+auaQSzPVIkElHpB0aO6M3TsKzVairPWSgU4HQ6FRFFGotbhUtWUrVaDTfffDM++clP4u677173fc888wx+/OMfY2JiYs1rBw8exPz8PA4dOoROp4P7778fDzzwAL797W9f6nA2BZIRU6/XFUVa75xAa4bKhZ/VLWV56qoMV+k3ViZGGf6iJc0zmGgxtlotlMtltFotZLNZZLNZdfLmVoc2dCXVbrdVbo7KlSE7hk0l00+29wHOz63P50MikVA9Dvm5crmsPAcZ8gP6wzS6VMi1IQuvpTckWVz0RpmTYg6L8ymFCd8ra/D6mau82uBeCQQCKpTOa63VashmsygUCmvOgRsGyPsl826s25T5KN5Leo65XA4nT55EvV5XSorGrqy5pDzjXvR4PCo6xLWzsrKCaDQKh8OBarUKn8+nDKN+ralLVlJ33XUX7rrrrgu+Z25uDp/5zGfwD//wD/jwhz9seu2NN97AD37wA7z88svYv38/AOCb3/wmPvShD+HP/uzPLJXa1QKFHAUIOyi3Wi0Eg0EVuvP5fKoOodPpqCOr5U2SoRye2ktPjK8DqyELClySJxqNhqLQNptNLC8vK4sagFKg7NS+nge1lZtTKmYKUVpvAJSX6HQ61XHyLFzmZpM1QDQA2F+sXq8rK0+eP6UrqkEE1xZ/l8pKdo9gSFO+LqnDesE051b33vl+GS4c1Lm5HMgwn8xrynCf3BPA8Fy/zpaVJCO9OF4aN9VqFbVaTRUvNxoNxW6U64sGcKPRUIpIemQ6YUfPPfd7Hjc9J9Xr9XDvvffi85//PN75zneuef3FF19EPB5XCgoADhw4AKfTiZdeegkf+9jH1nyG9FuiXC5v2ngl/bdSqeDs2bPweDwolUqIRCJIp9Oo1+uK1ZdKpRCPxzEyMmKyLpiTaTQaWFxcVOezNJtNJZQprOmF8drK5TKq1SqKxSIKhQIajQbm5+eV4iJzh8JIHmVxIU/takCGLPmT+YBOp4NisagUL0NaDPfJ2h5SYJm34+9UeAw3lEol9V3cQPr5UoPsJch5krF9aXxIdp7sKsE8FO8xvVAqdyowGgj0ZmVeRh/HsIJ7h91gmOynYG02myiVSuoomGG5XqmgKE9kdIXFuswTMfTW6/WQzWaRz+eRy+Vw5swZdRwO1wMAxSQmxbzb7SIUCiEUCql1xLmSSl9XUlspY3RsupL6yle+Arfbjc9+9rOWry8sLGBsbMw8CLcbyWQSCwsLlp95/PHH8Ud/9EebPVQTeCPk6bDA+fNZisUiut0u8vk8ACjrV1KqacGy1T1jwszLsACTC4bCigJdelP1el0pJ/7N8TG8NkgHAcpFLBvGUrHQI5Qxd84HSRLM8+khUHkujiSUDFuuRVcYupWqCwM5n1YWrbx+6c1fbF0Mwnq5XKzXAYYGAA3FQb/Gi61dvWRDGicAlIfEXC0NVl6/HvrXCVf8H1bjsFJK/Z7PTVVShw8fxje+8Q0cOXJkU4XIF77wBTzyyCPq73K5jJ07d27a9/MmyPOker2e6awVn8+HN998U8WGaf0zRCW/g3RyPhhD15uGer1eRYSoVCrI5XJYXFxEs9lUHgkXn5VV0y/rRs8FUZjSo5QhKeZPqKjpEbBVEj1Or9drOmSSRAvmHarVqgpjyaMI5P0bNKynVPS/pTcvPWNZ4CsFlxRgMnxsRTAZ1Lm5VMicMOsYZZi02WyiXC6bClEHEXpOx+p13mvmpNjDUe59Fi9Xq1XU63XFqtXXHI0/WQvFB3NcNJr5HfV6XX2vXnumG1ZbgU1VUv/4j/+IbDaLqakp9dzKygp+7/d+D1//+tdx8uRJZDIZZLNZ0+fopWQyGcvvJT35akFOtqRN08NhNwgeuyGVDZkzMoxDsgW/NxQKmbpSSEopm62yfT7ZScxrUdHx++RYB4WODphzJLKjOy1Ahu9YByYLoIHzHitDgnr+gd4nv0OGSPp93RvFhRSWDOXyfvM5kiykB6k/CJm/2m6Q7D5ZNA+shpxlWHgYoYf+ZPmLNPx00ozV2U9yfcgmACyCZgSDyh4w59VpIPN/9dMg3FQlde+99+LAgQOm5z7wgQ/g3nvvxf333w8AuOOOO1AsFnH48GHceuutAIBnn30WvV4Pt99++2YO55IgvQKHw2HKH5Dpx4JJGXJgrknPNVC4ADDRsYPBoFogbHdUKpVUEpT/Sy4OqwWy1dbMRmAVu6YAkZ4lw6r8yQaz8ngFhgJDoZAq+NU/qwvpQZoLHboA4hqyoovrBAu90wiLgFno6ff7VfjUKowzyPNyMUhBy36aLOLl2pJCdVjp58DaBs6AOYQLrCprlqdwHUQiEdNZbpRPbrdbMfhSqRSSySRCoRASiYTqDSp7PzKvRVmkH0DaD1yykqpWq3jzzTfV37Ozs3j11VeRTCYxNTWFVCpler/H40Emk8E73vEOAMC+ffvwwQ9+EJ/61Kfw1FNPodPp4KGHHsI999yzpcw+K+iCn8qKtSysoZKw+psPLpRAIIBcLgev14t4PK7cbDIIeWxzsVhErVYzdSe4WH5hEDakHAetMWn5kfTCa5FFmVTeNAZk92+/349oNAqv14tyuayEN2s26FUNwhxsBFwXMtcmlRShsxilQmORJTuj0NihZ2qV+CaGZZ50cC9Fo1GkUinFTGN+VuZ/B92TsiL7rBf2k16Tzg52OBwqFCjz1MypS68pkUjA7/cjlUohlUohEAio5rz8Lp7Wy5w6ZZFVukFex1bgkpXUK6+8gve///3qb+aK7rvvPnzrW9/a0Hc8/fTTeOihh3DnnXeqYt4nnnjiUodyVbAeY0y/KRdaYDJP4HK5FDmi1+up3muy1ojJT+k5XWxBDBJxQI+zyxCDBAWLJEHodFtJlJC/WyXMhw16mE52mpBJcc4bc51WXQfYv02v19uu0HtWAuaO8tJLH0boe13mn/XOItwTTCNwnVBJ0WChkuLx8SwMln1BZf6TLGqdhNFPBQVchpJ63/ved0mDPHny5Jrnkslk3wp3N4qNWqD6azJUKBPhFDayBRALV+WxzXqvuvXGMWgCySruTUuNY5XJfnm0NR/JZFLVglCIk05LoWyVjxg2yPyKPFEVWJ0jJscNw4Df71f96jKZDHw+H6LRqPKgSJaQgloKlmFWYDL5HwqFEI1GVX662+2qwz9Z/C6bqQKDuT6swrFWRCSyhSk3gPNF8bFYDC6XC/F4XCkTWbZAxcW9xDy6zG+xoLdaraLZbKJSqSCbzaJeryOfzytPykpZbTXs3n2bDGltUJgyfEcBJNuL9Ho9kyc1rGGa9RhockPSM2JCWHazlt4Bv6/Vaq2hnw+rFyVh5UnRy5TFzVwH8qhwniHE2hmSe3TDZpgVkw49TCrnim2hmM8cdE/qQutXKitenwz3MVROhmMgEFjjcXEuZL5TGn78/5IZyZwe228xbKoTMvoFW0ldZcjFxkI8hiiolGgJ6y3xB1XIXKi+Qg9LSO+JhYmSgp5IJFRPsmQyqRh8TOTSoiTLUs7VoNRxbBQUoJKFJ2vu6GHxetg6imUPkUgEkUhEhWvYMYD5GD6kZzUsc7MeKFh7vfPd4wOBABYXFzE/P49Op6PKN5aXl5WiGmRCje7lWXlVlBdUHABQKpVQKBTQ6/VUxIGMWGA1PUGPSo82yPwW91On08Hi4iIKhQKKxaLq/1culxVxYqubBVjBVlJXEdJ954LkAmInBr6Pi2jYOwXwWmTsnLUY8hiUUCgEj8ejOnj4fD5EIhE4nU5V98HzcLipyD7Sjw4YZOg5BsMwlGKSdHG97ocdFpxOJ8LhMEKhEMLhsCKSSHJFo9FQD1rBg1TsvRlgWNzpdGJhYQHz8/NoNpt46623UCqVsLS0ZJpPveXPoM2DVY6bz8mCeBKpSqWSIozwGgOBgDrxm3k6qVD4Ow1jng1FRjEb0mazWdWklsd+8DODUHNnK6ktgJXSkQlyq/zBoG2qi8Fq7BQQknLPujIqKTIdZf6KtRo6tVjmHIZ1fmSimgKD1r8klshwoCTisLBStsii92RVLzPskPPG0B5biDGPyzZQVqUgg4iL5bilMUNmca1WQ7lchtvtxtLSkjppgeUb9Kh477lGZLNq2dsvn8+j1Wohn8+rdlKy/EXW6/V7Lm0ltUWQXhX/lrkHvtZPFs1GoYcp9I0lQ01OpxOxWEwlvck0ikaj6tgFHi/Pz7MtFKmw7PzBcN9GGZCDAmmYMNfGsJ5hGIpuT2Ej+zwyFMhQTjabVd/B7gCFQgHtdlsJGoZ8htnoIaTRwqNbzp49i1AopEKADG+yq4n87DCB+4qkmV7vfD9RtkUjuaFcLiMQCGBkZETtIzZi5r6gcddqtbC8vKwiEVTqPCSRxAkqMel5rVejudWwldQWQuZrqKT014dxY/Hnet4gk7j0qOSDeSvJaCJln5RYqzzUsEGOmfddhlNkuEZ+RnoSMsxJZSS9KL3wchjX03qQbZ/q9bpSWGxsTOU0bMSaCxl88p6zUbVhGAgEAqjX63A4HOo4Hyslxb2Ty+WUkuK6KZfLptwUDQGdkTwIsJVUH7DRmz+oYQurZC83lQzVkWXUbDZN1HQ+zxNFSTWvVqtot9tYWFhAuVzG8vIyzp49q5K5Mh81rOA8yftKYSProZjTk6w2mQyXJyEzwa13CJD/c1gh1xUP82O3eAAq/Lm8vKwE77CRavS8mRw7WcE0TCqVCqrVKtxuN86ePau8bRbPy3Af1wK748u5YURCRj340ypS0U/YSmqLsV4id1AV0kYhmWskBcj+YswnsBcflRU3A+szmMwlm2lhYcEkiPWWS8QwzJ+em5TeNE+Alkw/+VMvjNZzD9ICXm+OhhkUtlwHjUZDEZEMw1BtxTgnwHBduz5WuT5Y9N9sNuFwOFAsFgGsNg2Qhs96kQ39f+jvW28MgwBbSfUBuqKSvw/KwtgI5HVwo7C5LMMyZCYxRk6vqlqtqiJFegHMreTzeVOBpoyPrxcjH9Z5k/VyfI3XIokAF/JeJZtrGNfRxaDPF40WGd6SLDR+ZlhhZchaMRUlSeRCSudCSkr/3ervfsNWUn2CvkiGwRMgdOXKh0zoM+zndrvRaDRMRbvsOOFwOEzFg9VqVSk6CiP2Yut3J+bNhi44ZHhOV0gbybNsFwG9HqTXyTwKsDo326UujFgvWnA53zHssJXUgGAYF5SVJyhJASREyAJm5hRoCVNJkakmvYF+nmGz1bCybC+1tc92nRviQgp9kBL9Vwvb/frWg62kbFwx9FCDrAVyOBxKIcnwFXMsMqein6oqredBSeJuJa61670YpJJimFR/zcb2g62kbGwqdEIAANVZQ2KjoQtb+NjQsd29ahtm2ErKRl9gCxgbNmxsBM6Lv8WGDRs2bNjoD7aNJxUMBjE9Pa2K2q517Ny5U527Q3CObJzH1NQU/H6/6blAIIDp6WlTe51rGdPT06ptFREIBDA1NWUZxr0WYTVHfr8fU1NTqov5tY7p6WkEg8HL+qzDGMK4S7lcRiwWQ6lUQjQaBQAsLy/j6NGj6uTbax2RSAT79u1T8wMA+XweR48etTfOLxAOh7Fv3z7EYjH1XKFQwNGjR1Gr1fo4ssFBKBTC3r17kUgk1HPFYhFvvPGGPUe/QDAYxL59+0xzVCqV8MYbb6BarfZxZIODYDCIvXv3IplMques5LgVto2SsmHDhg0bw4ONynE7J2XDhg0bNgYWtpKyYcOGDRsDi6EkTjBCWS6X+zwSGzZs2LBxOaD8vljGaSiVVKVSAXCewWbDhg0bNoYXlUrFRF7SMZTEiV6vh2PHjuHGG2/EmTNnhpY8US6XsXPnTvsa+ohhHz8w/Ncw7OMH7Gu4HBjG+dOGJyYm1hxFIzGUnpTT6cTk5CQAIBqNDu2iIOxr6D+GffzA8F/DsI8fsK/hUnEhD4qwiRM2bNiwYWNgYSspGzZs2LAxsBhaJeXz+fDFL35xTeufYYJ9Df3HsI8fGP5rGPbxA/Y1XE0MJXHChg0bNmxcGxhaT8qGDRs2bGx/2ErKhg0bNmwMLGwlZcOGDRs2Bha2krJhw4YNGwMLW0nZsGHDho2BxdAqqb/8y7/Erl274Pf7cfvtt+MnP/lJv4dkiccffxy/8iu/gkgkgrGxMXz0ox/FsWPHTO9pNpt48MEHkUqlEA6H8fGPfxyLi4t9GvHF8ad/+qdwOBx4+OGH1XODfg1zc3P4V//qXyGVSiEQCOBd73oXXnnlFfW6YRj4d//u32F8fByBQAAHDhzAiRMn+jhiM1ZWVvDYY49hZmYGgUAA119/Pb70pS+ZmnMO2jW88MIL+PVf/3VMTEzA4XDgO9/5jun1jYw3n8/j4MGDiEajiMfj+O3f/u0tO0jwQuPvdDp49NFH8a53vQuhUAgTExP4rd/6LZw7d25gxn+xa9Dx6U9/Gg6HA1//+tdNz/f7GoZSSf3P//k/8cgjj+CLX/wijhw5gptvvhkf+MAHkM1m+z20NXj++efx4IMP4sc//jEOHTqETqeDf/7P/7npVNPf/d3fxXe/+1387d/+LZ5//nmcO3cOd999dx9HvT5efvll/NVf/RV+6Zd+yfT8IF9DoVDAe9/7Xng8Hnz/+9/H66+/jj//8z83naT61a9+FU888QSeeuopvPTSSwiFQvjABz6AZrPZx5Gv4itf+QqefPJJ/Kf/9J/wxhtv4Ctf+Qq++tWv4pvf/KZ6z6BdQ61Ww80334y//Mu/tHx9I+M9ePAgXnvtNRw6dAjf+9738MILL+CBBx7o+/jr9TqOHDmCxx57DEeOHMHf/d3f4dixY/jIRz5iel8/xw9c/B4QzzzzDH784x9jYmJizWv9vgYYQ4jbbrvNePDBB9XfKysrxsTEhPH444/3cVQbQzabNQAYzz//vGEYhlEsFg2Px2P87d/+rXrPG2+8YQAwXnzxxX4N0xKVSsXYvXu3cejQIeOf/bN/Znzuc58zDGPwr+HRRx81fu3Xfm3d13u9npHJZIyvfe1r6rlisWj4fD7jf/yP/7EVQ7woPvzhDxuf/OQnTc/dfffdxsGDBw3DGPxrAGA888wz6u+NjPf11183ABgvv/yyes/3v/99w+FwGHNzc1s2dsNYO34r/OQnPzEAGKdOnTIMY7DGbxjrX8PZs2eNyclJ4+c//7kxPT1t/MVf/IV6bRCuYeg8qXa7jcOHD+PAgQPqOafTiQMHDuDFF1/s48g2hlKpBABIJpMAgMOHD6PT6ZiuZ+/evZiamhq463nwwQfx4Q9/2DRWYPCv4e///u+xf/9+/Mt/+S8xNjaGW265BX/913+tXp+dncXCwoJp/LFYDLfffvtAjB8AfvVXfxU//OEPcfz4cQDA//t//w8/+tGPcNdddwEYjmuQ2Mh4X3zxRcTjcezfv1+958CBA3A6nXjppZe2fMwXQ6lUgsPhQDweBzAc4+/1erj33nvx+c9/Hu985zvXvD4I1zB0XdCXlpawsrKCdDptej6dTuPo0aN9GtXG0Ov18PDDD+O9730vbrrpJgDAwsICvF6vWthEOp3GwsJCH0Zpjb/5m7/BkSNH8PLLL695bdCv4e2338aTTz6JRx55BP/m3/wbvPzyy/jsZz8Lr9eL++67T43Rak0NwvgB4A/+4A9QLpexd+9euFwurKys4Mtf/jIOHjwIAENxDRIbGe/CwgLGxsZMr7vdbiSTyYG7pmaziUcffRSf+MQnVAfxYRj/V77yFbjdbnz2s5+1fH0QrmHolNQw48EHH8TPf/5z/OhHP+r3UC4JZ86cwec+9zkcOnQIfr+/38O5ZPR6Pezfvx//4T/8BwDALbfcgp///Od46qmncN999/V5dBvD//pf/wtPP/00vv3tb+Od73wnXn31VTz88MOYmJgYmmvYruh0OvjN3/xNGIaBJ598st/D2TAOHz6Mb3zjGzhy5AgcDke/h7Muhi7cNzIyApfLtYY5tri4iEwm06dRXRwPPfQQvve97+G5557Djh071POZTAbtdhvFYtH0/kG6nsOHDyObzeKXf/mX4Xa74Xa78fzzz+OJJ56A2+1GOp0e6GsYHx/HjTfeaHpu3759OH36NACoMQ7ymvr85z+PP/iDP8A999yDd73rXbj33nvxu7/7u3j88ccBDMc1SGxkvJlMZg0ZqtvtIp/PD8w1UUGdOnUKhw4dMp3DNOjj/8d//Edks1lMTU2pfX3q1Cn83u/9Hnbt2gVgMK5h6JSU1+vFrbfeih/+8IfquV6vhx/+8Ie44447+jgyaxiGgYceegjPPPMMnn32WczMzJhev/XWW+HxeEzXc+zYMZw+fXpgrufOO+/EP/3TP+HVV19Vj/379+PgwYPq90G+hve+971raP/Hjx/H9PQ0AGBmZgaZTMY0/nK5jJdeemkgxg+cZ5Ppp5e6XC70ej0Aw3ENEhsZ7x133IFisYjDhw+r9zz77LPo9Xq4/fbbt3zMOqigTpw4gf/zf/4PUqmU6fVBH/+9996Ln/3sZ6Z9PTExgc9//vP4h3/4BwADcg1bQs/YZPzN3/yN4fP5jG9961vG66+/bjzwwANGPB43FhYW+j20Nfid3/kdIxaLGf/3//5fY35+Xj3q9bp6z6c//WljamrKePbZZ41XXnnFuOOOO4w77rijj6O+OCS7zzAG+xp+8pOfGG632/jyl79snDhxwnj66aeNYDBo/Pf//t/Ve/70T//UiMfjxv/+3//b+NnPfmb8xm/8hjEzM2M0Go0+jnwV9913nzE5OWl873vfM2ZnZ42/+7u/M0ZGRozf//3fV+8ZtGuoVCrGT3/6U+OnP/2pAcD4j//xPxo//elPFfttI+P94Ac/aNxyyy3GSy+9ZPzoRz8ydu/ebXziE5/o+/jb7bbxkY98xNixY4fx6quvmvZ2q9UaiPFf7BqsoLP7DKP/1zCUSsowDOOb3/ymMTU1ZXi9XuO2224zfvzjH/d7SJYAYPn4L//lv6j3NBoN41//639tJBIJIxgMGh/72MeM+fn5/g16A9CV1KBfw3e/+13jpptuMnw+n7F3717jP//n/2x6vdfrGY899piRTqcNn89n3HnnncaxY8f6NNq1KJfLxuc+9zljamrK8Pv9xnXXXWf84R/+oUkgDto1PPfcc5Zr/7777tvweJeXl41PfOITRjgcNqLRqHH//fcblUql7+OfnZ1dd28/99xzAzH+i12DFayUVL+vwT5PyoYNGzZsDCyGLidlw4YNGzauHdhKyoYNGzZsDCxsJWXDhg0bNgYWtpKyYcOGDRsDC1tJ2bBhw4aNgYWtpGzYsGHDxsDCVlI2bNiwYWNgYSspGzZs2LAxsLCVlA0bNmzYGFjYSsqGDRs2bAwsbCVlw4YNGzYGFv8fwd6hjEkhzmgAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "size = 25\n",
    "sample = generator.sample(size)\n",
    "image_tensor = sample.view(-1, config['channels'], config['size'], config['size']).cpu()\n",
    "nrow = int(np.ceil(np.sqrt(size)))\n",
    "visual_plt.plot_images_from_tensor(image_tensor, title='Samples from generative model', nrow=nrow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "75b21830",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_list = []\n",
    "for i in range(contexts):\n",
    "    plot_list.append(plotting_dict[\"acc per context\"][\"context {}\".format(i + 1)])\n",
    "figure = visual_plt.plot_lines(\n",
    "    plot_list, x_axes=plotting_dict[\"x_iteration\"],\n",
    "    line_names=['Context {}'.format(i + 1) for i in range(contexts)],\n",
    "    ylabel=\"Test accuracy (per context)\", ylim=(0,1.05) if scenario==\"class\" else None,\n",
    "    xlabel=\"Iteration\", title=\"{}  --  {}-incremental learning\".format(experiment, scenario)\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00d3deb7",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
